codex-tools: extract MCP schema adapters (#15928)

## Why

`codex-tools` already owns the shared tool input schema model and parser
from the first extraction step, but `core/src/tools/spec.rs` still owned
the MCP-specific adapter that normalizes `rmcp::model::Tool` schemas and
wraps `structuredContent` into the call result output schema.

Keeping that adapter in `codex-core` means the reusable MCP schema path
is still split across crates, and the unit tests for that logic stay
anchored in `codex-core` even though the runtime orchestration does not
need to move yet.

This change takes the next small step by moving the reusable MCP schema
adapter into `codex-tools` while leaving `ResponsesApiTool` assembly in
`codex-core`.

## What changed

- added `tools/src/mcp_tool.rs` and sibling
`tools/src/mcp_tool_tests.rs`
- introduced `ParsedMcpTool`, `parse_mcp_tool()`, and
`mcp_call_tool_result_output_schema()` in `codex-tools`
- updated `core/src/tools/spec.rs` to consume parsed MCP tool parts from
`codex-tools`
- removed the now-redundant MCP schema unit tests from
`core/src/tools/spec_tests.rs`
- expanded `codex-rs/tools/README.md` to describe this second migration
step

## Test plan

- `cargo test -p codex-tools`
- `cargo test -p codex-core --lib tools::spec::`

codex-rs/tools/src/mcp_tool.rs

@@ -0,0 +1,65 @@
+use crate::JsonSchema;
+use crate::parse_tool_input_schema;
+use serde_json::Value as JsonValue;
+use serde_json::json;
+
+/// Parsed MCP tool metadata and schemas that can be adapted into a higher-level
+/// tool spec by downstream crates.
+#[derive(Debug, PartialEq)]
+pub struct ParsedMcpTool {
+    pub description: String,
+    pub input_schema: JsonSchema,
+    pub output_schema: JsonValue,
+}
+
+pub fn parse_mcp_tool(tool: &rmcp::model::Tool) -> Result<ParsedMcpTool, serde_json::Error> {
+    let mut serialized_input_schema = serde_json::Value::Object(tool.input_schema.as_ref().clone());
+
+    // OpenAI models mandate the "properties" field in the schema. Some MCP
+    // servers omit it (or set it to null), so we insert an empty object to
+    // match the behavior of the Agents SDK.
+    if let serde_json::Value::Object(obj) = &mut serialized_input_schema
+        && obj.get("properties").is_none_or(serde_json::Value::is_null)
+    {
+        obj.insert(
+            "properties".to_string(),
+            serde_json::Value::Object(serde_json::Map::new()),
+        );
+    }
+
+    let input_schema = parse_tool_input_schema(&serialized_input_schema)?;
+    let structured_content_schema = tool
+        .output_schema
+        .as_ref()
+        .map(|output_schema| serde_json::Value::Object(output_schema.as_ref().clone()))
+        .unwrap_or_else(|| JsonValue::Object(serde_json::Map::new()));
+
+    Ok(ParsedMcpTool {
+        description: tool.description.clone().map(Into::into).unwrap_or_default(),
+        input_schema,
+        output_schema: mcp_call_tool_result_output_schema(structured_content_schema),
+    })
+}
+
+pub fn mcp_call_tool_result_output_schema(structured_content_schema: JsonValue) -> JsonValue {
+    json!({
+        "type": "object",
+        "properties": {
+            "content": {
+                "type": "array",
+                "items": {}
+            },
+            "structuredContent": structured_content_schema,
+            "isError": {
+                "type": "boolean"
+            },
+            "_meta": {}
+        },
+        "required": ["content"],
+        "additionalProperties": false
+    })
+}
+
+#[cfg(test)]
+#[path = "mcp_tool_tests.rs"]
+mod tests;