perf: Phase F-6 — compact replay benchmarks (2.2x speedup measured)

Benchmark results (1M events, LRU, release mode):
- String replay:  160ms
- Compact replay:  72ms  (2.2x faster)
- intern_batch:   121ms  (one-time conversion cost)

For N-policy comparison (compare command), amortized cost:
- String: 160ms × N
- Compact: 121ms + 72ms × N  (wins at N >= 2)

New benchmarks:
- lru_replay_1m_string vs lru_replay_1m_compact
- intern_batch_1m (conversion overhead)
- memory_string_100k vs memory_compact_100k (clone cost proxy)

Author: albert-einshutoin

crates/qc-simulate/benches/trace_replay.rs

@@ -1,6 +1,8 @@
 use criterion::{black_box, criterion_group, criterion_main, Criterion};
+use qc_model::compact_trace::CompactTraceEvent;
 use qc_simulate::baselines::{GdsfPolicy, LruPolicy};
-use qc_simulate::engine::TraceReplayEngine;
+use qc_simulate::compact_baselines::CompactLruPolicy;
+use qc_simulate::engine::{CompactReplayEconConfig, ReplayEconConfig, TraceReplayEngine};
 use qc_simulate::synthetic::{self, SyntheticConfig};
 
 fn generate_trace(n: usize) -> Vec<qc_model::trace::RequestTraceEvent> {
@@ -16,7 +18,7 @@ fn generate_trace(n: usize) -> Vec<qc_model::trace::RequestTraceEvent> {
 fn bench_lru_replay_1m(c: &mut Criterion) {
     let events = generate_trace(1_000_000);
 
-    c.bench_function("lru_replay_1m", |b| {
+    c.bench_function("lru_replay_1m_string", |b| {
         b.iter(|| {
             let mut policy = LruPolicy::new(50_000_000);
             let metrics = TraceReplayEngine::replay(black_box(&events), &mut policy).unwrap();
@@ -25,6 +27,26 @@ fn bench_lru_replay_1m(c: &mut Criterion) {
     });
 }
 
+fn bench_lru_replay_1m_compact(c: &mut Criterion) {
+    let events = generate_trace(1_000_000);
+    let (compact_events, mut interner) = CompactTraceEvent::intern_batch(&events);
+    let econ =
+        CompactReplayEconConfig::from_econ_config(&ReplayEconConfig::default(), &mut interner);
+
+    c.bench_function("lru_replay_1m_compact", |b| {
+        b.iter(|| {
+            let mut policy = CompactLruPolicy::new(50_000_000);
+            let metrics = TraceReplayEngine::replay_compact_with_econ(
+                black_box(&compact_events),
+                &mut policy,
+                &econ,
+            )
+            .unwrap();
+            black_box(metrics);
+        })
+    });
+}
+
 fn bench_gdsf_replay_1m(c: &mut Criterion) {
     let events = generate_trace(1_000_000);
 
@@ -37,5 +59,44 @@ fn bench_gdsf_replay_1m(c: &mut Criterion) {
     });
 }
 
-criterion_group!(benches, bench_lru_replay_1m, bench_gdsf_replay_1m);
+fn bench_intern_batch_1m(c: &mut Criterion) {
+    let events = generate_trace(1_000_000);
+
+    c.bench_function("intern_batch_1m", |b| {
+        b.iter(|| {
+            let (compact, interner) = CompactTraceEvent::intern_batch(black_box(&events));
+            black_box((compact, interner));
+        })
+    });
+}
+
+fn bench_memory_comparison(c: &mut Criterion) {
+    let events = generate_trace(100_000);
+
+    c.bench_function("memory_string_100k", |b| {
+        b.iter(|| {
+            let e = events.clone();
+            black_box(e.len());
+        })
+    });
+
+    let (compact_events, interner) = CompactTraceEvent::intern_batch(&events);
+
+    c.bench_function("memory_compact_100k", |b| {
+        b.iter(|| {
+            let e = compact_events.clone();
+            let i = interner.clone();
+            black_box((e.len(), i.len()));
+        })
+    });
+}
+
+criterion_group!(
+    benches,
+    bench_lru_replay_1m,
+    bench_lru_replay_1m_compact,
+    bench_gdsf_replay_1m,
+    bench_intern_batch_1m,
+    bench_memory_comparison
+);
 criterion_main!(benches);