[andystaples]

Warning

Do not merge this PR, or any other PR in the stack, on its own. The whole stack will be squash-merged once every PR in it is approved.

Layer 1/6 of the async orchestrator stack, which splits the closed #293 for review. It is based on #356.

Scope

• shared.is_async_callable classifies orchestrator callables. Each callable is checked directly first: coroutine functions are async and generator functions are synchronous, even when they carry functools.wraps metadata from a function of the other kind. Partials and callable objects resolve through func and __call__; only a callable that is neither falls back to the function it wraps. Cyclic __wrapped__ chains are reported as errors.
• The worker registry classifies each orchestrator once, at registration, so wrapper cycles fail when the orchestrator is registered rather than on every dispatch.
• Validation at the point where the worker calls the orchestrator:
  • A sync callable that returns a coroutine is rejected, and the coroutine is closed.
  • An async-classified callable that returns something other than a coroutine is rejected with guidance about functools.wraps. If it returned a generator, that generator is closed.
  • Async generators are rejected.
  • Generators that yield anything other than a Task are rejected.
• The worker runs coroutine orchestrators and resumes them during replay through a minimal deterministic DurableEventLoop (durabletask/internal/asyncio_loop.py). This loop is enough to:
  • drive the root coroutine
  • suspend it on durable tasks
  • deliver completions
  • fail when the orchestrator is blocked on work that isn't durable
• loop.time() is derived from the replay-safe orchestration clock (naive or timezone-aware). Loop timers, including asyncio.sleep() with a positive delay, fail with an error that points to ctx.create_timer(...) until [Async stack 2/6] asyncio composition and durable timers #358 adds durable loop timers.
• The module docstring of asyncio_loop.py lists each private asyncio API the loop depends on and why.
• Task.__await__ and Task.wait() are now concrete. Inside the durable loop, awaiting suspends on the durable task. With no running loop, __await__ yields the task itself so mock-based drivers can send results. Under a different running event loop, it raises RuntimeError.
• Adds the SyncOrchestrator, AsyncOrchestrator, and Orchestrator aliases.
• Generator orchestrator behavior is unchanged, and a new test replays a generator history in the form earlier releases record it. Teardown now always closes the orchestrator, whether it is a generator or a coroutine.

Temporary differences (resolved in later layers)

• Context: async orchestrators receive the existing OrchestrationContext, and AsyncOrchestrator is typed against it. Layer 4/6 ([Async stack 4/6] Add cold async orchestration context #361) adds the cold AsyncOrchestrationContext, its tests, and the context API and metadata parity tests.
• Event loop: general asyncio composition (durable timers and asyncio.sleep with a positive delay, TaskGroup ordering) and the executor and thread guards come in layer 2/6 ([Async stack 2/6] asyncio composition and durable timers #358).
• Teardown: the cleanup and quiesce policy and async-generator hooks come in layer 3/6 ([Async stack 3/6] Dispatch cleanup for coroutine orchestrators #360).
• Changelog: layers 0-5 do not touch changelogs. The release entries are added only in layer 6/6 ([Async stack 6/6] Document coroutine orchestrators and add Managed compatibility tests #364).