feat: add History::posterior_of for a linear combination of competitors

#46: every accessor returns a per-competitor marginal, and almost
nothing a consumer publishes is one competitor. Combining marginals
assumes independence, and competitors are correlated through every event
they share.

`posterior_of(&[(a, 1.0), (b, -1.0)])` returns the posterior of that
combination with the correlation intact. Validated against the exact
linear-Gaussian posterior on both a tree and a loopy fixture, for
differences and for single competitors: agreement to 1e-9 relative in
every case.

The investigation that preceded this is why it is not a covariance
accessor. Marginals from loopy message passing are about half the true
width, and ignoring correlation overstates a difference — the two errors
partially cancel, leaving 1.327x rather than 2.646x. Bolting true
correlations onto the existing marginals would have given 0.765 against
a true 1.524, which is overconfident: the direction the reporter
specifically called unsafe. Rebuilding the joint from the factor
structure fixes both at once, and a single-competitor query now returns
the exact marginal rather than the narrow one.

The precision matrix depends only on structure — who played whom, with
what weights and what noise — not on the observed outcomes, and the
means were already exact. So only the second moment is reconstructed.

Known limits, all deliberate and documented on the method:

- Latest slice only. A functional spanning times, such as "current
  versus career", needs the time-expanded joint and is not covered.
- Scored events only. A ranked outcome's truncation is EP-approximated
  and its converged factors are not retained after inference, so ranked
  slices return `JointUnavailable` rather than a plausible wrong number.
- Dense Cholesky, O(n^3) per query in the slice's competitor count:
  38.8us at 50, 5.66ms at 400, 49.1ms at 800. Fine for the sizes this
  serves today; caching the factorization per slice would make repeat
  queries O(n^2), and sparsity is the next step after that.

Refs #46, #47, #48

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_011hcFjNDmHXZF8URGLku5zZ

src/time_slice.rs

@@ -809,6 +809,93 @@ pub(crate) fn compute_elapsed<T: Time>(last: Option<&T>, current: &T) -> i64 {
     elapsed.max(0)
 }
 
+impl<T: Time> TimeSlice<T> {
+    /// Precision matrix of the joint posterior over this slice's competitors.
+    ///
+    /// Message passing produces per-competitor marginals and throws the
+    /// correlation away — `Item::likelihood` is already the projection of an
+    /// event's factor down onto one competitor. So the joint has to be rebuilt
+    /// from the factor structure rather than recovered from the messages.
+    ///
+    /// Usefully, a precision matrix depends only on *structure* — who played
+    /// whom, with what weights and what observation noise — and not on the
+    /// observed outcomes. The means are already exact (Gaussian belief
+    /// propagation gets those right even with cycles), so only the second
+    /// moment needs rebuilding.
+    ///
+    /// Returns the competitor order and the dense matrix in row-major order.
+    /// Only scored events contribute their factors exactly; see the caller.
+    pub(crate) fn joint_precision<D: Drift<T>>(
+        &self,
+        agents: &CompetitorStore<T, D>,
+    ) -> (Vec<Index>, Vec<f64>) {
+        let order: Vec<Index> = self.skills.keys().collect();
+        let n = order.len();
+        let mut row_of: HashMap<Index, usize> = HashMap::with_capacity(n);
+        for (r, idx) in order.iter().enumerate() {
+            row_of.insert(*idx, r);
+        }
+
+        let mut lambda = vec![0.0; n * n];
+
+        // Everything outside this slice enters as each competitor's forward and
+        // backward messages, which message passing treats as independent.
+        for (r, idx) in order.iter().enumerate() {
+            let skill = self.skills.get(*idx).expect("slice key has a skill");
+            lambda[r * n + r] += (skill.forward * skill.backward).pi();
+        }
+
+        for event in &self.events {
+            let EventKind::Scored { score_sigma } = event.kind else {
+                continue;
+            };
+
+            // Teams best-first, matching the diff chain inference builds.
+            let mut order_idx: Vec<usize> = (0..event.teams.len()).collect();
+            order_idx.sort_by(|&a, &b| {
+                event.teams[b]
+                    .output
+                    .partial_cmp(&event.teams[a].output)
+                    .unwrap_or(std::cmp::Ordering::Equal)
+            });
+
+            for pair in order_idx.windows(2) {
+                let (hi, lo) = (pair[0], pair[1]);
+
+                // Contrast vector, and the observation noise that sits on top
+                // of the skills: per-member performance noise plus the score
+                // noise itself.
+                let mut contrast: HashMap<usize, f64> = HashMap::new();
+                let mut noise = score_sigma * score_sigma;
+
+                for (team, sign) in [(hi, 1.0), (lo, -1.0)] {
+                    for (m, item) in event.teams[team].items.iter().enumerate() {
+                        let w = event.weights[team][m];
+                        let beta = agents[item.agent].rating.beta;
+                        noise += w * w * beta * beta;
+                        *contrast.entry(row_of[&item.agent]).or_insert(0.0) += sign * w;
+                    }
+                }
+
+                for (&i, &ci) in &contrast {
+                    for (&j, &cj) in &contrast {
+                        lambda[i * n + j] += ci * cj / noise;
+                    }
+                }
+            }
+        }
+
+        (order, lambda)
+    }
+
+    /// True when every event here is scored, so `joint_precision` is exact.
+    pub(crate) fn all_scored(&self) -> bool {
+        self.events
+            .iter()
+            .all(|e| matches!(e.kind, EventKind::Scored { .. }))
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use approx::assert_ulps_eq;