T4 (MarginFactor): scored outcomes via Gaussian-margin EP evidence

Adds soft Gaussian-observation evidence on the per-pair diff variable,
enabling continuous score margins as a richer alternative to ranks.

Public API:
- `Outcome::Scored([scores])` (non-breaking enum extension under
  `#[non_exhaustive]`).
- `Game::scored(teams, outcome, options)` constructor parallel to
  `Game::ranked`.
- `EventBuilder::scores([...])` fluent helper.
- `HistoryBuilder::score_sigma(σ)` knob (default 1.0, validated > 0).
- `GameOptions::score_sigma`.
- `EventKind` re-exported from `lib.rs` (annotated `#[non_exhaustive]`).
- New `InferenceError::InvalidParameter { name, value }` variant.

Internals:
- `MarginFactor` (`factor/margin.rs`): Gaussian observation factor that
  closes in one EP step; cavity-cached log-evidence mirrors `TruncFactor`.
- `BuiltinFactor::Margin` dispatch arm.
- `DiffFactor` enum in `game.rs` lets `Game::likelihoods` and the new
  `likelihoods_scored` share the per-pair link abstraction.
- Per-event `EventKind { Ranked, Scored { score_sigma } }` routed through
  `TimeSlice::add_events`, `iteration_direct`, and `log_evidence`.

Tests: 88 lib + 27 integration (4 new in `tests/scored.rs`); existing
goldens byte-identical.  Bench: `benches/scored.rs` baseline ~960µs for
60 events × 20-player pool with default convergence.

Plan: docs/superpowers/plans/2026-04-27-t4-margin-factor.md
Spec item marked Done.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

src/factor/margin.rs

@@ -0,0 +1,123 @@
+use crate::{
+    N_INF,
+    factor::{Factor, VarId, VarStore},
+    gaussian::Gaussian,
+    pdf,
+};
+
+/// Gaussian observation factor on a diff variable.
+///
+/// Encodes the soft evidence `m_obs ~ N(diff, sigma²)`. The outgoing message
+/// to `diff` is the constant `N(m_obs, sigma²)`, so this factor converges in a
+/// single propagation: subsequent calls return a zero delta.
+#[derive(Debug)]
+pub struct MarginFactor {
+    pub diff: VarId,
+    pub m_obs: f64,
+    pub sigma: f64,
+    pub(crate) msg: Gaussian,
+    pub(crate) evidence_cached: Option<f64>,
+}
+
+impl MarginFactor {
+    pub fn new(diff: VarId, m_obs: f64, sigma: f64) -> Self {
+        debug_assert!(sigma > 0.0, "score sigma must be positive");
+        Self {
+            diff,
+            m_obs,
+            sigma,
+            msg: N_INF,
+            evidence_cached: None,
+        }
+    }
+}
+
+impl Factor for MarginFactor {
+    fn propagate(&mut self, vars: &mut VarStore) -> (f64, f64) {
+        let marginal = vars.get(self.diff);
+        let cavity = marginal / self.msg;
+
+        if self.evidence_cached.is_none() {
+            self.evidence_cached = Some(cavity_evidence(cavity, self.m_obs, self.sigma));
+        }
+
+        let new_msg = Gaussian::from_ms(self.m_obs, self.sigma);
+        let new_marginal = cavity * new_msg;
+        let old_msg = self.msg;
+        self.msg = new_msg;
+        vars.set(self.diff, new_marginal);
+
+        old_msg.delta(new_msg)
+    }
+
+    fn log_evidence(&self, _vars: &VarStore) -> f64 {
+        self.evidence_cached.unwrap_or(1.0).ln()
+    }
+}
+
+fn cavity_evidence(cavity: Gaussian, m_obs: f64, sigma: f64) -> f64 {
+    let combined_sigma = (cavity.sigma().powi(2) + sigma.powi(2)).sqrt();
+    pdf(m_obs, cavity.mu(), combined_sigma)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn first_propagate_writes_tilted_marginal() {
+        let mut vars = VarStore::new();
+        let diff = vars.alloc(Gaussian::from_ms(0.0, 6.0));
+        let mut f = MarginFactor::new(diff, 5.0, 1.0);
+
+        f.propagate(&mut vars);
+
+        let result = vars.get(diff);
+        // pi = 1/36 + 1 ≈ 1.027778; tau = 0 + 5 = 5
+        // mu = 5 / 1.027778 ≈ 4.864865; sigma = 1/sqrt(1.027778) ≈ 0.986394
+        assert!((result.mu() - 4.864864864864865).abs() < 1e-12);
+        assert!((result.sigma() - 0.986393923832144).abs() < 1e-12);
+    }
+
+    #[test]
+    fn converges_in_one_step() {
+        let mut vars = VarStore::new();
+        let diff = vars.alloc(Gaussian::from_ms(0.0, 6.0));
+        let mut f = MarginFactor::new(diff, 5.0, 1.0);
+
+        f.propagate(&mut vars);
+        let (dmu, dsig) = f.propagate(&mut vars);
+        assert!(
+            dmu < 1e-12,
+            "expected ~0 delta on second propagate, got {dmu}"
+        );
+        assert!(dsig < 1e-12);
+    }
+
+    #[test]
+    fn evidence_cached_on_first_propagate() {
+        let mut vars = VarStore::new();
+        let diff = vars.alloc(Gaussian::from_ms(0.0, 6.0));
+        let mut f = MarginFactor::new(diff, 5.0, 1.0);
+        assert!(f.evidence_cached.is_none());
+
+        f.propagate(&mut vars);
+        let z = f.evidence_cached.unwrap();
+        // pdf(5, 0, sqrt(37)) ≈ 0.046783
+        assert!((z - 0.04678300292616668).abs() < 1e-10);
+
+        // Subsequent propagations don't change it.
+        f.propagate(&mut vars);
+        assert_eq!(f.evidence_cached.unwrap(), z);
+    }
+
+    #[test]
+    fn log_evidence_matches_cached_ln() {
+        let mut vars = VarStore::new();
+        let diff = vars.alloc(Gaussian::from_ms(0.0, 6.0));
+        let mut f = MarginFactor::new(diff, 5.0, 1.0);
+        f.propagate(&mut vars);
+        let logz = f.log_evidence(&vars);
+        assert!((logz - (-3.062235327364623)).abs() < 1e-10);
+    }
+}