Add SSE server transport for HTTP+SSE filter chain

[gophergogo]

Summary

• Implement the server side of MCP's SSE transport inside HttpSseJsonRpcProtocolFilter: long-lived GET {sse_path} opens a stream, the server announces a callback/{session_id} URL via event: endpoint, and subsequent POST /callback/{session_id} bodies are 202 Accepted while the real JSON-RPC response is routed back through the matching SSE stream.
• Introduce SseSessionRegistry, owned by HttpSseFilterChainFactory (not a process singleton), mapping session IDs to the SSE-stream Connection*. Lifetime is bounded by the server; all access is on the dispatcher thread, asserted but lock-free.
• Add configurable sse_path, rpc_path, and external_url to McpServerConfig + HttpSseFilterChainFactory, wire them through McpServer's fallback factory construction, and default http_sse_path to /sse to match the Python/TypeScript MCP SDKs.
• Match POST /callback/{id} anywhere in the request path so deployments behind a reverse proxy (Traefik, nginx, ingress) that rewrites the URL still route correctly when external_url is set to the proxy-side base.

Design notes

• Per-factory registry, not a global singleton. The upstream draft used a process-wide map guarded by std::mutex with cross-thread connection->write() calls. That conflicts with the dispatcher-thread invariant and the project preference for state machines over mutex-guarded shared state, and leaks session IDs across McpServer instances in the same process. A per-factory registry keeps lifetime bounded by the server and needs no lock because all filter callbacks run on the same dispatcher thread — asserted on every registry entry point.
• Filter owns the registration lifecycle. registerSession in onHeaders for GET {sse_path}; removeSession in the filter destructor when the SSE-stream connection tears down. Both run on the dispatcher thread per the filter/connection contract, so a POST /callback arriving in the narrow "SSE closed but filter not yet destructed" window sees an already-consistent registry and returns a clean lookup miss.
• Handshake write re-entry. onHeaders writes the HTTP 200 prelude + event: endpoint inline via connection().write(). An sse_writing_handshake_ pass-through flag keeps our own onWrite from re-framing those raw bytes as an SSE event when the write chain calls back in — the alternative (posting through the dispatcher) would race the client reading the handshake before we could register the session.
• Response routing via StopIteration. When sse_callback_session_id_ is set on the POST connection, onWrite drains the response buffer, hands the JSON to the registry, and returns StopIteration so the JSON never lands on the POST connection (which already got its 202).
• Reverse-proxy callback match. Changed the POST match from "path begins with /callback/" to "path contains /callback/ anywhere," using rfind to recover the session ID from the tail. Direct deployments still work because there is only one /callback/ occurrence and rfind lands at position 0.
• Intentionally diverges from upstream in two places. (1) No active_connections_ post-based deferral rewrite — the PR Fix connection lifetime and init-path crashes #212 crash-fix stack already replaced that with Dispatcher::deferredDelete, which is the correct primitive and handles the use-after-free window that post() only partially covers. (2) No debug request-log line in the reverse-proxy fix — it's noise, not part of the routing change.

Files

• include/mcp/server/mcp_server.h — http_sse_path default becomes /sse; new external_url field.
• include/mcp/filter/http_sse_filter_chain_factory.h — ctor takes trailing sse_path, rpc_path, external_url; forward-declares SseSessionRegistry; out-of-line ctor/dtor to accommodate the unique_ptr member.
• src/filter/http_sse_filter_chain_factory.cc — SseSessionRegistry class; HttpSseJsonRpcProtocolFilter gets server-transport state (sse_server_mode_, sse_writing_handshake_, sse_session_id_, sse_callback_session_id_) and the onHeaders / onWrite / onBody transport paths.
• src/server/mcp_server.cc — fallback factory construction now passes http_sse_path, http_rpc_path, and external_url through.

Test plan

• All 10 existing HttpSse / HttpsSse / SseCodec / HttpCodecSse cases still pass — the new transport is opt-in via the GET {sse_path} / POST /callback/{id} URL pattern; factories that don't use those paths see no behavioral change.
• cmake --build build --target gopher-mcp clean.
• No references to legacy http_transport_socket.h.
• Dispatcher-thread asserts on every SseSessionRegistry entry point; registry mutation all happens from filter callbacks.
• Real-IO integration test (full GET /sse → endpoint announce → POST /callback/{id} → response routed back through stream) will follow as part of PR D alongside the other integration-level tests carved out of Fix connection lifetime and init-path crashes #212.

Context

Third carve-out from PR #211's larger "feature/gateway-sse-transport" bundle, following the crash fixes in #212 and the async HTTP client in #213. This PR lands the SSE server transport that uses the async HTTP client's counterpart direction — POST callback response routing via a session registry. The remaining integration-level tests (including a round-trip test for this transport) will follow as PR D.

[github-actions]

❌ Code Formatting Check Failed

Some files in this PR are not properly formatted according to the project's clang-format rules.

To fix this issue:

make format

Then commit and push the changes.