fix: move inline codex-rs/core unit tests into sibling files (#14444)

## Why
PR #13783 moved the `codex.rs` unit tests into `codex_tests.rs`. This
applies the same extraction pattern across the rest of `codex-rs/core`
so the production modules stay focused on runtime code instead of large
inline test blocks.

Keeping the tests in sibling files also makes follow-up edits easier to
review because product changes no longer have to share a file with
hundreds or thousands of lines of test scaffolding.

## What changed
- replaced each inline `mod tests { ... }` in `codex-rs/core/src/**`
with a path-based module declaration
- moved each extracted unit test module into a sibling `*_tests.rs`
file, using `mod_tests.rs` for `mod.rs` modules
- preserved the existing `cfg(...)` guards and module-local structure so
the refactor remains structural rather than behavioral

## Testing
- `cargo test -p codex-core --lib` (`1653 passed; 0 failed; 5 ignored`)
- `just fix -p codex-core`
- `cargo fmt --check`
- `cargo shear`

codex-rs/core/src/turn_timing_tests.rs

@@ -0,0 +1,125 @@
+use codex_protocol::items::AgentMessageItem;
+use codex_protocol::items::TurnItem;
+use codex_protocol::models::ContentItem;
+use codex_protocol::models::FunctionCallOutputPayload;
+use codex_protocol::models::ResponseItem;
+use pretty_assertions::assert_eq;
+use std::time::Instant;
+
+use super::TurnTimingState;
+use super::response_item_records_turn_ttft;
+use crate::ResponseEvent;
+
+#[tokio::test]
+async fn turn_timing_state_records_ttft_only_once_per_turn() {
+    let state = TurnTimingState::default();
+    assert_eq!(
+        state
+            .record_ttft_for_response_event(&ResponseEvent::OutputTextDelta("hi".to_string()))
+            .await,
+        None
+    );
+
+    state.mark_turn_started(Instant::now()).await;
+    assert_eq!(
+        state
+            .record_ttft_for_response_event(&ResponseEvent::Created)
+            .await,
+        None
+    );
+    assert!(
+        state
+            .record_ttft_for_response_event(&ResponseEvent::OutputTextDelta("hi".to_string()))
+            .await
+            .is_some()
+    );
+    assert_eq!(
+        state
+            .record_ttft_for_response_event(&ResponseEvent::OutputTextDelta("again".to_string()))
+            .await,
+        None
+    );
+}
+
+#[tokio::test]
+async fn turn_timing_state_records_ttfm_independently_of_ttft() {
+    let state = TurnTimingState::default();
+    state.mark_turn_started(Instant::now()).await;
+
+    assert!(
+        state
+            .record_ttft_for_response_event(&ResponseEvent::OutputTextDelta("hi".to_string()))
+            .await
+            .is_some()
+    );
+    assert!(
+        state
+            .record_ttfm_for_turn_item(&TurnItem::AgentMessage(AgentMessageItem {
+                id: "msg-1".to_string(),
+                content: Vec::new(),
+                phase: None,
+            }))
+            .await
+            .is_some()
+    );
+    assert_eq!(
+        state
+            .record_ttfm_for_turn_item(&TurnItem::AgentMessage(AgentMessageItem {
+                id: "msg-2".to_string(),
+                content: Vec::new(),
+                phase: None,
+            }))
+            .await,
+        None
+    );
+}
+
+#[test]
+fn response_item_records_turn_ttft_for_first_output_signals() {
+    assert!(response_item_records_turn_ttft(
+        &ResponseItem::FunctionCall {
+            id: None,
+            name: "shell".to_string(),
+            namespace: None,
+            arguments: "{}".to_string(),
+            call_id: "call-1".to_string(),
+        }
+    ));
+    assert!(response_item_records_turn_ttft(
+        &ResponseItem::CustomToolCall {
+            id: None,
+            status: None,
+            call_id: "call-2".to_string(),
+            name: "custom".to_string(),
+            input: "echo hi".to_string(),
+        }
+    ));
+    assert!(response_item_records_turn_ttft(&ResponseItem::Message {
+        id: None,
+        role: "assistant".to_string(),
+        content: vec![ContentItem::OutputText {
+            text: "hello".to_string(),
+        }],
+        end_turn: None,
+        phase: None,
+    }));
+}
+
+#[test]
+fn response_item_records_turn_ttft_ignores_empty_non_output_items() {
+    assert!(!response_item_records_turn_ttft(&ResponseItem::Message {
+        id: None,
+        role: "assistant".to_string(),
+        content: vec![ContentItem::OutputText {
+            text: String::new(),
+        }],
+        end_turn: None,
+        phase: None,
+    }));
+    assert!(!response_item_records_turn_ttft(
+        &ResponseItem::FunctionCallOutput {
+            call_id: "call-1".to_string(),
+            output: FunctionCallOutputPayload::from_text("ok".to_string()),
+        }
+    ));
+}