[simontreanor]

Makes Pyfun's async { } behave like F#'s async: cold and composable. Building a value runs nothing, and every await is a fresh run.

Before: an Async a was a Python coroutine, so it was single-shot. Awaiting the same value twice raised RuntimeError: cannot reuse already awaited coroutine, and Async.parallel [job, job] ran job once, because gather deduplicates identical arguments. The type system already described cold semantics (DESIGN §8 attributes the effect at the await); now the runtime matches.

How it lowers:

• An Async is an emitted _pf_Async(fn, *args) whose __await__ calls fn(*args) afresh. let job = async { … } → job = _pf_Async(_pf_fn0). A saturated call of an extern returning Async → _pf_Async(f, a, b), with the function and arguments evaluated at once. Every Async/Task helper is a plain def returning one.
• The emitter prints await _pf_Async(f, *args) as await f(*args), so the output still reads await inbox.get() and await asyncio.sleep(0.01).
• Where Python insists on a real coroutine, a value goes through async def _pf_run(a): return await a. That covers an extern parameter typed Async a (asyncio.run(_pf_run(main))), a callback parameter returning Async, a unit -> Async a thunk, and each element Async.parallel/race start. In a project, the exporting module's binding adapts, since a dependent knows only the arity.
• The async self tail call now gives the coroutine its loop variables as parameters (async def g(n, acc): while True: … → _pf_Async(g, n, acc)), so each await starts from the original arguments. With no nonlocal left in that shape, native: a parameter rebound through nonlocal stays unannotated #174's un-annotating pass has nothing to do and is removed.

The callback case (raised during review of the plan): asyncio.start_server schedules a handler's result only if it is a coroutine, so a handler returning _pf_Async would silently never run. e2e_an_async_callback_handed_to_python_runs runs a real server with a Pyfun handler. I confirmed it tells the two apart: with the raw handler, the client reads Some('') with no error; adapted, it reads Some('HELLO').

Breaking: Python code handed a Pyfun Async now receives an awaitable rather than a coroutine. It can await it any number of times, or call it for a fresh coroutine, as with a zero-argument async def: asyncio.run(job()). Python 3.14's asyncio.run(job) accepts the value directly; 3.12 and 3.13 need the call. CI caught this, since two tests hand Python a Pyfun value. A bare or partially applied async extern (urls |> List.map fetch) uses the same adapting lambda as the project binding, so its results are cold too.

Tests: e2e for cold re-runs (the same value awaited twice and passed to Async.parallel twice runs four times), the start_server callback, and a two-module project (an imported Async extern re-runs, and its argument reaches asyncio.run as a coroutine). Existing tests updated for the new shapes.

Docs: DESIGN §5.4/§5.6/§8, INTERNALS, ROADMAP, and lesson 18, which gains an "Awaiting a value twice" section with a verified example; its notebook is regenerated.

Python 3.12: every e2e program also ran under 3.12 in Docker. 285 of 287 match 3.14; the two others differ only in glibc's math.cbrt(27.0) (3.0000000000000004), which predates this change.

Checked locally: cargo fmt, cargo clippy --all-targets (clean), cargo test (every binary), docs/verify_lessons.py, build_notebooks.py --check, tests/kernel_e2e.py (all pass, including the async cell), and tests/native_parity.py: 84 of 84 match under mypyc.