feat: cooperative scheduling — close the four CPython divergences

[ivarvong]

Stacked on top of #58. Closes the four documented divergences from CPython by converting coroutines to tagged generators driven by a cooperative trampoline.

The discovery

Pyex already had what cooperative scheduling needs: the `:lazy_iter` generator continuation infrastructure (used by sync generators, the islice fix, FastAPI streaming). The Phase 1 "sync trampoline" was actually a regression from the existing primitives — it ran coroutines to completion instead of letting them suspend.

The Phase 1.5 model is the natural one PEP 380 + 492 specify: coroutines are sync generators with a `kind` flag, `await EXPR` is yield-from over the inner iterator, and the trampoline interprets known sentinels. Same machinery for sync generators and coroutines, just driven by different surfaces.

What ships

```python
import asyncio

trace = []
async def step(label):
for _ in range(3):
trace.append(label)
await asyncio.sleep(0)

async def main():
await asyncio.gather(step("A"), step("B"))
return "".join(trace)

asyncio.run(main())

'ABABAB' — matches CPython, was 'AAABBB' in #58

```

The four divergences from #58, all closed:

	#58 (Phase 1)	this PR	CPython
`gather` interleaving	sequential	round-robin	round-robin
`create_task`	drives eagerly	lazy (driven on `await`)	lazy
Nested `asyncio.run`	silently allowed	`RuntimeError`	`RuntimeError`
`[x async for x in g()]`	parse error	parses + runs	parses + runs

The four `@tag :phase1_divergence` tests in the conformance suite are flipped to assert CPython parity instead of pinning divergence. When you read those tests, they're now positive specifications — what Pyex does — not regrets.

Mechanically

• New iter-pool entries: `{:gen_unstarted, body, env}` (CPython parity: calling an async def doesn't run the body) and `{:gen_done, value}` (PEP 380 `StopIteration(value)`).
• `Invocation.build_coroutine` no longer eval-runs the body — stages it in `:gen_unstarted`. First `await` runs it via `run_unstarted`.
• `eval({:await, ...})` calls `Invocation.initiate_await` — advance one step, propagate yields up with a `:cont_await_iter` frame, surface the inner's return value as the result. `r = await coro` lands the StopIteration value in `r` via `:cont_bind_sent`.
• `asyncio.sleep(t)` builds a single-yield coroutine with an `{:asyncio_sleep, ms}` sentinel. Sentinels propagate up through the await chain to the trampoline.
• `asyncio.gather` is a round-robin Elixir-side trampoline: advance each pending child one step per round, sleep inline on sentinels, collect in declared order. Returns a Task.
• `asyncio.create_task` returns `{:asyncio_task_pending, coro}`; `await pending_task` drives the wrapped coroutine. Pending Task methods report the right CPython values (`done() -> False`, `result()` raises `InvalidStateError`).
• `ctx.asyncio_running` flag for nested-loop detection.
• Parser accepts `async for` inside list/set/dict comprehensions and generator expressions.

Test plan

• `mix format --check-formatted` clean
• `mix compile --warnings-as-errors` clean
• `mix test` — 5346 tests, 0 failures, 2 skipped
• `mix dialyzer` — 40 errors / 40 skipped (baseline: 41/41 — one fewer skip needed, none added)
• All four divergence tests flipped to assert CPython parity, all pass
• Existing async tests (gather order, exception propagation, Task methods, async methods on classes) still pass
• FastAPI streaming async generators (lazy_iter path) still work
• islice over infinite generators still works (uses the same iter-pool primitives)

Why I'm proud of this one

The cooperative trampoline is ~100 lines of Elixir. It works because Pyex's design is right — generators-as-continuations is the substrate, and async/await sits on top of it in the way PEP 492 originally specified. Building a real event loop on the BEAM normally means processes and message passing; this one is pure functional code that the `BannedCallTracer` accepts unchanged.

🤖 Generated with Claude Code