Expose a cancellable route watch API in Python

[kixelated]

Problem

Python handles route changes differently from the other bindings. BroadcastConsumer.route_changed() lazily creates a route watch, caches it in a private field, and awaits its next value:

• Python BroadcastConsumer route handling

The watch handle is not public and has no deterministic cancellation path. A caller that abandons route observation must rely on garbage collection or broadcast shutdown to release the native watch.

Other wrappers expose explicit lifetime ownership:

• Go RouteWatch.Next(ctx) and Cancel
• Swift exposes a cancellable asynchronous sequence.
• Kotlin exposes a Flow that cancels the watch in finally.

Proposed direction

Expose a public Python route watch abstraction with deterministic cleanup, following the existing wrapper conventions. Suitable shapes include:

• an async iterator returned by routes()
• an async context-managed RouteWatch
• both, with route_changed() retained only as a convenience over the owned watch

The owner should be able to cancel a pending wait and release the native resource without waiting for garbage collection.

Acceptance criteria

• Python callers can explicitly own and close a route watch.
• Abandoning iteration deterministically cancels the native watch.
• A pending route wait is cancellable by normal asyncio task cancellation.
• Tests cover early iterator exit and cancellation while waiting.
• Lifecycle documentation matches the Go, Swift, and Kotlin ownership contract.

(Written by GPT-5.6)

[kixelated]

Finalized plan:

• Add a public RouteWatch wrapper around the native route-update consumer.
• Add BroadcastConsumer.route_updates() -> RouteWatch as the canonical API.
• Make RouteWatch an async iterator and async context manager, with a terminal cancel() for explicit cleanup.
• Keep route_changed() compatible by lazily caching a RouteWatch.
• Export RouteWatch from the moq package and document canonical async with ... / async for ... usage.
• Cover the initial route, ordered updates, clean termination, context-manager cleanup, pending-read cancellation, reuse after a timed-out read, and existing route_changed() behavior.

This is additive and should target main.

(Written by GPT-5.6)

[kixelated]

Implemented in #3229.

The PR adds the Python RouteWatch async iterator/context manager, preserves route_changed() via a cached cursor, and fixes cancellation at the shared FFI task layer so a cancelled or timed-out wait does not strand the watch state. just fix, just check, and just test pass on the final rebased tree.

(Written by GPT-5.6)