feat(prerecorded): add AsyncTranscriber for asyncio callers

[he-james]

Adds aai.AsyncTranscriber, the asyncio counterpart of Transcriber. Every API
call is a coroutine, so transcriptions run concurrently on one thread. Closes #80.

Rebased onto master now that #226 has landed. Two commits, reviewable separately:

1. _base.py — no behavior change. TranscriptFields (the 27 response
   accessors), _BaseTranscript, _BaseTranscriber. Both concurrency models
   inherit them, which is the base-class sharing refactor(transcriber): move prerecorded transcription into prerecorded/v2 #226 deferred. transcript.py
   drops 190 lines.
2. The feature — async_transcript.py, async_client.py, async_api.py in
   prerecorded/v2, plus AsyncClient beside the root Client. Same
   one-class-per-module layout as the threaded twins. Every _*Impl survives.

async with aai.AsyncTranscriber() as transcriber:
    transcript = await transcriber.transcribe("./audio.mp3")
    sentences = await transcript.get_sentences()

Four deliberate divergences from the threaded API

1. No default AsyncClient. An httpx.AsyncClient pool belongs to the loop
   that first used it, so a global one dies on a second asyncio.run().
   AsyncTranscriber owns one per instance; pass a client to share a pool.
2. get_by_id/delete_by_id are on the transcriber, not classmethods on the
   transcript, because the async transcript needs the transcriber's pool.
3. Group methods never drop errors. First error raises after the batch
   settles, or return_failures=True gives (transcripts, errors). They also
   keep input order and cap in-flight work at max_concurrency (default 8).
4. Uploads set Content-Length when the size is known, so httpx skips
   chunked encoding. Verified on httpx 0.19, 0.22, 0.24, 0.28.

Testing

433 passed, 3 failed (pyaudio, also failing on base). Green on httpx 0.22 /
0.24 / 0.28 and under both pydantic paths. mypy + ruff clean. #226's
backwards-compat test still passes. 45 new tests, including two that pin the
shared bases and two that prove real concurrency.

Not verified: no live-API run yet, and no Python 3.8 interpreter (tox starts at
3.9).

Known gap

api.py still inlines its own error strings, so the per-endpoint messages exist
in both api.py and async_api.py. _base._raise_for_status is ready; switching
api.py over is one line per function. Left out to keep the diff additive — happy
to fold it in.

[he-james]

Live production verification

Same method as #226, plus a leg for the asyncio work. One shared transcript created up front, every read path deep-compared as normalized JSON. Baseline is origin/master (9a251f2), the exact parent of these two commits, so any difference is caused by this PR and nothing else.

Three legs, all green:

leg	covers	result
threaded parity	origin/master vs this branch, using only pre-refactor import paths	✅ identical
asyncio parity	the same read paths through AsyncTranscriber vs the threaded path on this branch	✅ identical
asyncio-only behavior	streamed upload, group order + concurrency cap, return_failures	✅ 5/5

Byte-identical across both parity legs: all 27 accessors that commit 1 moved into TranscriptFields, config, get_sentences, get_paragraphs, VTT text, SRT-with-chars_per_caption text, word_search, a before_id-pinned list_transcripts page (ids and statuses), TranscriptGroup.get_by_ids, the redaction config, the redacted-audio URL prefix, the client-side redaction guard, and a fresh transcription's text and word count.

Asyncio-only results: upload returns an https URL; transcribe_group returns 3 in input order at max_concurrency=2 in 6.3s; return_failures accounts for every item; async fresh text matches the threaded fresh text.

15 transcripts created and deleted per run, audio capped to the first 30s via audio_end_at.

🤖 Generated with Claude Code