[3/4] Add executor-backed RMCP HTTP client (#18583)

### Why
The RMCP layer needs a Streamable HTTP client that can talk either
directly over `reqwest` or through the executor HTTP runner without
duplicating MCP session logic higher in the stack. This PR adds that
client-side transport boundary so remote Streamable HTTP MCP can reuse
the same RMCP flow as the local path.

### What
- Add a shared `rmcp-client/src/streamable_http/` module with:
  - `transport_client.rs` for the local-or-remote transport enum
  - `local_client.rs` for the direct `reqwest` implementation
  - `remote_client.rs` for the executor-backed implementation
  - `common.rs` for the small shared Streamable HTTP helpers
- Teach `RmcpClient` to build Streamable HTTP transports in either local
or remote mode while keeping the existing OAuth ownership in RMCP.
- Translate remote POST, GET, and DELETE session operations into
executor `http/request` calls.
- Preserve RMCP session expiry handling and reconnect behavior for the
remote transport.
- Add remote transport coverage in
`rmcp-client/tests/streamable_http_remote.rs` and keep the shared test
support in `rmcp-client/tests/streamable_http_test_support.rs`.

### Verification
- `cargo check -p codex-rmcp-client`
- online CI

### Stack
1. #18581 protocol
2. #18582 runner
3. #18583 RMCP client
4. #18584 manager wiring and local/remote coverage

---------

Co-authored-by: Codex <noreply@openai.com>

codex-rs/rmcp-client/tests/streamable_http_remote.rs

@@ -0,0 +1,37 @@
+//! Integration coverage for the remote Streamable HTTP RMCP path.
+//!
+//! These tests exercise the orchestrator-side RMCP adapter against a real
+//! `exec-server` process so HTTP requests go through the remote runtime path
+//! instead of direct local `reqwest` calls.
+
+mod streamable_http_test_support;
+
+use pretty_assertions::assert_eq;
+
+use streamable_http_test_support::call_echo_tool;
+use streamable_http_test_support::create_remote_client;
+use streamable_http_test_support::expected_echo_result;
+use streamable_http_test_support::spawn_exec_server;
+use streamable_http_test_support::spawn_streamable_http_server;
+
+/// What this tests: the RMCP remote Streamable HTTP adapter can initialize
+/// a server and call a tool while every MCP HTTP request goes through a real
+/// exec-server process instead of a direct reqwest transport.
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn streamable_http_remote_client_round_trips_through_exec_server() -> anyhow::Result<()> {
+    // Phase 1: start the MCP Streamable HTTP test server and a local
+    // exec-server process that will own the HTTP network calls.
+    let (_server, base_url) = spawn_streamable_http_server().await?;
+    let exec_server = spawn_exec_server().await?;
+
+    // Phase 2: create and initialize the RMCP client using the executor-backed
+    // Streamable HTTP transport.
+    let client = create_remote_client(&base_url, exec_server.client.clone()).await?;
+
+    // Phase 3: prove the initialized client can complete a tool call and
+    // preserve the normal RMCP response shape.
+    let result = call_echo_tool(&client, "remote").await?;
+    assert_eq!(result, expected_echo_result("remote"));
+
+    Ok(())
+}