T0 + T1 + T2: engine redesign through new API surface (#1)

Implements tiers T0, T1, T2 of `docs/superpowers/specs/2026-04-23-trueskill-engine-redesign-design.md`. All three tiers have landed together on this branch because they build on one another; this PR rolls them up for a single review pass.

Per-tier plans:
- T0: `docs/superpowers/plans/2026-04-23-t0-numerical-parity.md`
- T1: `docs/superpowers/plans/2026-04-24-t1-factor-graph.md`
- T2: `docs/superpowers/plans/2026-04-24-t2-new-api-surface.md`

## Summary

### T0 — Numerical parity (internal)

- `Gaussian` switched to natural-parameter storage `(pi, tau)`; mul/div now ~7× faster (218 ps vs 1.57 ns).
- `HashMap<Index, _>` → dense `Vec<_>` keyed by `Index.0` (via `AgentStore<D>`, `SkillStore`).
- `ScratchArena` eliminates per-event allocations in `Game::likelihoods`.
- `InferenceError` seed type added (1 variant).
- 38 → 53 tests passing through T1.
- Benchmark: `Batch::iteration` 29.84 → 21.25 µs.

### T1 — Factor graph machinery (internal)

- `Factor` trait + `BuiltinFactor` enum (TeamSum / RankDiff / Trunc) driving within-game inference.
- `VarStore` flat storage for variable marginals.
- `Schedule` trait + `EpsilonOrMax` impl replacing the hand-rolled EP loop.
- `Game::likelihoods` rebuilt on the factor-graph machinery; iteration counts and goldens preserved to within 1e-6.
- 53 tests passing.
- Benchmark: `Batch::iteration` 23.01 µs (slight regression absorbed in T2).

### T2 — New API surface (breaking)

**Renames:**
- `IndexMap → KeyTable`, `Player → Rating`, `Agent → Competitor`, `Batch → TimeSlice`

**New types:**
- `Time` trait with `Untimed` ZST and `i64` impls; `Drift<T>`, `Rating<T, D>`, `Competitor<T, D>`, `TimeSlice<T>`, `History<T, D, O, K>` all generic.
- `Event<T, K>`, `Team<K>`, `Member<K>`, `Outcome` (`Ranked` variant; `#[non_exhaustive]`).
- `Observer<T>` trait + `NullObserver`.
- `ConvergenceOptions`, `ConvergenceReport`.
- `GameOptions`, `OwnedGame<T, D>`.

**Three-tier ingestion:**
- `history.record_winner(&K, &K, T)` / `record_draw(&K, &K, T)` — 1v1 convenience.
- `history.add_events(iter)` — typed bulk.
- `history.event(T).team([...]).weights([...]).ranking([...]).commit()` — fluent.

**Query API:** `current_skill`, `learning_curve`, `learning_curves` (keyed on `K`), `log_evidence`, `log_evidence_for`, `predict_quality`, `predict_outcome`.

**Game constructors:** `ranked`, `one_v_one`, `free_for_all`, `custom` — all returning `Result<_, InferenceError>`.

**`factors` module:** `Factor`, `Schedule`, `VarStore`, `VarId`, `BuiltinFactor`, `EpsilonOrMax`, `ScheduleReport`, `TeamSumFactor`, `RankDiffFactor`, `TruncFactor` now public.

**Errors:** `InferenceError` gains `MismatchedShape`, `InvalidProbability`, `ConvergenceFailed`; boundary panics converted to `Result`.

**Removed (breaking):** `History::convergence(iters, eps, verbose)`, `HistoryBuilder::gamma(f64)`, `HistoryBuilder::time(bool)`, `History.time: bool`, `learning_curves_by_index`, nested-Vec public `add_events`.

## Behavior change (documented in CHANGELOG)

`Time = Untimed` has `elapsed_to → 0`, so no drift accumulates between slices. The old `time=false` mode implicitly forced `elapsed=1` on reappearance via an `i64::MAX` sentinel — that quirk is not reproducible under a typed time axis. Tests that depended on it now use `History::<i64, _>` with explicit `1..=n` timestamps. One test (`test_env_ttt`) had 3 Gaussian goldens updated to reflect the corrected semantics; documented in commit `33a7d90`.

## Final numbers

| Metric | Before T0 | After T2 | Delta |
|---|---|---|---|
| `Batch::iteration` | 29.84 µs | 21.36 µs | **-28%** |
| `Gaussian::mul` | 1.57 ns | 219 ps | **-86%** |
| `Gaussian::div` | 1.57 ns | 219 ps | **-86%** |
| Tests passing | 38 | 90 | +52 |

All other Gaussian ops unchanged (~219 ps add/sub, ~264 ps pi/tau reads).

## Test plan

- [x] `cargo test --features approx` — 90/90 pass (68 lib + 10 api_shape + 6 game + 4 record_winner + 2 equivalence)
- [x] `cargo clippy --all-targets --features approx -- -D warnings` — clean
- [x] `cargo +nightly fmt --check` — clean
- [x] `cargo bench --bench batch` — 21.36 µs
- [x] `cargo bench --bench gaussian` — unchanged from T1
- [x] `cargo run --example atp --features approx` — rewritten in new API, runs clean
- [x] Historical Game-level goldens preserved in `tests/equivalence.rs`
- [x] Public API matches spec Section 4 (verified by integration tests in `tests/api_shape.rs`)

## Commit history

~45 commits total across T0 + T1 + T2. Each task is self-contained and individually tested; the branch is bisectable. See `git log main..t2-new-api-surface` for the full list.

## Deferred to later tiers

- `Outcome::Scored` + `MarginFactor` — T4
- `Damped` / `Residual` schedules — T4
- `Send + Sync` bounds + Rayon parallelism — T3
- N-team `predict_outcome` — T4
- `Game::custom` full ergonomics — T4

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Reviewed-on: #1
Co-authored-by: Anders Olsson <anders.e.olsson@gmail.com>
Co-committed-by: Anders Olsson <anders.e.olsson@gmail.com>

src/factor/team_sum.rs

@@ -0,0 +1,98 @@
+use crate::{
+    N00,
+    factor::{Factor, VarId, VarStore},
+    gaussian::Gaussian,
+};
+
+/// Computes the weighted sum of player performances into a team-perf var.
+///
+/// Inputs are pre-computed player performance Gaussians (i.e., rating priors
+/// already with beta² noise added via `Rating::performance()`). The factor
+/// runs once per game and writes the weighted sum to the output var.
+#[derive(Debug)]
+pub struct TeamSumFactor {
+    pub inputs: Vec<(Gaussian, f64)>,
+    pub out: VarId,
+}
+
+impl Factor for TeamSumFactor {
+    fn propagate(&mut self, vars: &mut VarStore) -> (f64, f64) {
+        let perf = self.inputs.iter().fold(N00, |acc, (g, w)| acc + (*g * *w));
+        let old = vars.get(self.out);
+        vars.set(self.out, perf);
+        old.delta(perf)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::N_INF;
+
+    #[test]
+    fn single_player_unit_weight() {
+        let mut vars = VarStore::new();
+        let out = vars.alloc(N_INF);
+        let g = Gaussian::from_ms(25.0, 5.0);
+        let mut f = TeamSumFactor {
+            inputs: vec![(g, 1.0)],
+            out,
+        };
+
+        f.propagate(&mut vars);
+        let result = vars.get(out);
+        assert!((result.mu() - 25.0).abs() < 1e-12);
+        assert!((result.sigma() - 5.0).abs() < 1e-12);
+    }
+
+    #[test]
+    fn two_players_summed() {
+        let mut vars = VarStore::new();
+        let out = vars.alloc(N_INF);
+        let g1 = Gaussian::from_ms(20.0, 3.0);
+        let g2 = Gaussian::from_ms(30.0, 4.0);
+        let mut f = TeamSumFactor {
+            inputs: vec![(g1, 1.0), (g2, 1.0)],
+            out,
+        };
+
+        f.propagate(&mut vars);
+        let result = vars.get(out);
+        // sum: mu = 20 + 30 = 50, var = 9 + 16 = 25, sigma = 5
+        assert!((result.mu() - 50.0).abs() < 1e-12);
+        assert!((result.sigma() - 5.0).abs() < 1e-12);
+    }
+
+    #[test]
+    fn weighted_inputs() {
+        let mut vars = VarStore::new();
+        let out = vars.alloc(N_INF);
+        let g = Gaussian::from_ms(10.0, 2.0);
+        let mut f = TeamSumFactor {
+            inputs: vec![(g, 2.0)],
+            out,
+        };
+
+        f.propagate(&mut vars);
+        let result = vars.get(out);
+        // g * 2.0: mu = 10*2 = 20, sigma = 2*2 = 4
+        assert!((result.mu() - 20.0).abs() < 1e-12);
+        assert!((result.sigma() - 4.0).abs() < 1e-12);
+    }
+
+    #[test]
+    fn delta_is_zero_on_repeat_propagate() {
+        let mut vars = VarStore::new();
+        let out = vars.alloc(N_INF);
+        let g = Gaussian::from_ms(5.0, 1.0);
+        let mut f = TeamSumFactor {
+            inputs: vec![(g, 1.0)],
+            out,
+        };
+
+        f.propagate(&mut vars);
+        let (dmu, dsig) = f.propagate(&mut vars);
+        assert!(dmu < 1e-12, "expected ~0 delta on repeat, got {}", dmu);
+        assert!(dsig < 1e-12);
+    }
+}