refactor(execution_trace): Phase B language-advantage pass — dichotomy wave

Hash-indexed outcome map: the duplicate task_id dict-assignment law now
resolves through one O(N) pass (Vec + insertion-order HashMap index)
instead of the O(N²) find-then-scan — deterministic, allocation-light,
semantics identical (insertion order preserved). Battery 3/3 replays
frozen truth verbatim; live parity 820/820; clippy -D warnings clean.

src/rust/execution_trace/src/lib.rs

@@ -70,6 +70,12 @@ fn s(v: &str) -> Json {
 /// exact exception, so both core modes crash identically.
 pub fn read_outcome_events(lines: &[Json]) -> Result<Json, (String, String)> {
     let mut pairs: Vec<(String, Json)> = Vec::new();
+    // Phase B (language advantage): a hash index replaces the linear
+    // find-then-scan for duplicate task_ids — one pass over a journal of
+    // N lines is O(N) instead of O(N²), with insertion order preserved
+    // (the dict-assignment law needs first-seen ordering, not sorted).
+    let mut index: std::collections::HashMap<String, usize> =
+        std::collections::HashMap::new();
     for line in lines {
         let Json::Str(raw) = line else { continue }; // TypeError branch
         let rec = match pyjson::parse(raw) {
@@ -97,10 +103,12 @@ pub fn read_outcome_events(lines: &[Json]) -> Result<Json, (String, String)> {
             continue; // falsy task_id branch
         }
         // dict assignment: a later duplicate REPLACES the earlier payload
-        if let Some(slot) = pairs.iter_mut().find(|(k, _)| *k == tid) {
-            slot.1 = payload;
-        } else {
-            pairs.push((tid, payload));
+        match index.get(&tid) {
+            Some(&slot) => pairs[slot].1 = payload,
+            None => {
+                index.insert(tid.clone(), pairs.len());
+                pairs.push((tid, payload));
+            }
         }
     }
     Ok(Json::Obj(pairs))