feat!: Python callback streaming, std::sync::mpsc removed (refs #482)

[userFRM]

Summary

Stage 3 of issue #482: migrate the PyO3 binding to the SSOT StreamingDispatcher. The C ABI rewrite landed in PR #490; this PR brings Python in line. TypeScript follows in PR D, C++ in PR E.

Removed Python methods

• tdx.next_event(timeout_ms) -- poll-style entry point.
• tdx.next_event_typed(timeout_ms) -- alias for the above.

New method signature

tdx.start_streaming(callback=handler)
# `handler(event)` runs on the dispatcher's drain thread under the GIL

The PyO3 method:

fn start_streaming(&self, callback: Py<PyAny>) -> PyResult<()>

The wrapper struct stores ONLY the user's callable:

callback: Mutex<Option<Py<PyAny>>>,

EventRx, the rx field, the dropped_events: Arc<AtomicU64>, and every std::sync::mpsc reference are gone:

$ rg "std::sync::mpsc" sdks/python/ --type rust
$ # zero matches

Drop counter is now exposed via tdx.dropped_event_count(), forwarded to thetadatadx::ThetaDataDx::dropped_event_count. The value matches every other binding and survives reconnect because it lives on the SSOT dispatcher.

Migration

# Before
tdx.start_streaming()
while True:
    event = tdx.next_event(100)
    if event:
        process(event)

# After
def handler(event):
    process(event)
tdx.start_streaming(callback=handler)

GIL-acquire-in-dispatcher contract

Per-event flow:

1. FPSS reader thread decodes the wire frame and calls the dispatcher's send-side closure (cheap clone onto the bounded crossbeam_channel(8192) queue). Reader never blocks on user code.
2. Dispatcher drain thread pops the event, runs Python::attach(|py| { ... }), builds the typed pyclass via buffered_event_to_typed, and calls dispatch_cb.call1(py, (typed,)).
3. Exceptions raised inside callback are routed through PyErr::write_unraisable(py, None) so a buggy callback cannot kill the streaming thread.
4. Queue overflow drops the event and ticks the SSOT counter; consumers observe it via dropped_event_count().

Why no Python start_streaming_inline

GIL acquisition can block. A slow Python callable on the FPSS reader thread would:

1. Block the reader on Python::attach.
2. Fill the kernel TCP receive buffer.
3. Trigger TCP backpressure on the vendor side.
4. Cause the FPSS server to disconnect the session.

The Python binding deliberately does NOT expose the inline opt-in path. C ABI consumers can; Python cannot. Documented in the start_streaming docstring and in this PR's changelog entry.

Test plan

• cargo fmt --all -- --check
• cargo clippy --workspace --all-targets -- -D warnings
• cargo test --workspace
• cargo deny check
• cargo run -p thetadatadx --bin generate_sdk_surfaces --features config-file -- --check
• cargo check --manifest-path tools/mcp/Cargo.toml --locked
• cargo clippy --manifest-path tools/mcp/Cargo.toml --all-targets -- -D warnings
• cargo test --manifest-path tools/mcp/Cargo.toml --no-run
• cargo check --manifest-path tools/server/Cargo.toml --locked
• cargo check --manifest-path sdks/python/Cargo.toml --locked
• cargo check --manifest-path sdks/typescript/Cargo.toml --locked
• Final scrub: rg "std::sync::mpsc" sdks/python/ --type rust returns zero matches.
• Live FPSS smoke (pytest sdks/python/tests/test_dropped_events.py with THETADX_TEST_CREDS set) -- requires market access; runs in the surfaces CI job.

Out of scope

• Version bump. Cargo.tomls stay at 8.0.29. The single coherent breaking bump happens at PR E (C++) once every binding has migrated.
• TypeScript and C++ wrapper migrations -- PRs D and E.
• Wider docs-site streaming guide overhaul. The Python-specific accessor reference (tools/server.md) is updated; cross-language tables stay until TS / C++ migrate.

Refs #482.