fix: close out four small issues and pin #27's repro

#29 — log_evidence and log_evidence_for took &mut self while mutating
nothing. Loosening them to &self is not source-breaking for ordinary callers
(a &mut reborrows as & transparently) and brings them in line with the
filtered_* accessors added last week.

Not the mechanical change it looked like: under the rayon feature the closure
in log_evidence_internal captured all of &self rather than just the competitor
store, which drags KeyTable<K> in and demands K: Sync from every caller. That
compiled while the method took &mut self and stopped compiling the moment it
did not. Binding `let agents = &self.agents;` before the closure narrows the
capture; the comment there says why, because the next person to inline it will
reintroduce the bound.

#31 — TimeSlice::add_events constructed Skill with ..Default::default() while
filtered_step spells every field out. The design relies on a new Skill field
being a compile error at construction sites rather than a silent default, and
that tripwire only fired at one of the two. Now both.

#28 — log_evidence_internal's `forward` flag is a genuine forward-only
quantity only on a history that has never been converged, because iteration
alternates sweeps and the likelihood feeding the forward message absorbs
backward information from the second iteration onward. Documented, with a
pointer to filtered_log_evidence for the quantity that survives convergence.
That trap is one function away from the one #19 was about.

#23 — color_greedy carried #[allow(dead_code)] despite being called by
recompute_color_groups: a mute button on a live function, which is the
specific complaint in that issue.

#27 was already fixed — the guard landed in f4e2922 and the issue was filed
against 7742b2b, which merge-base confirms predates it — but nothing pinned
it. Added the issue's own reproduction, which matters because the two profiles
fail differently and a debug-only test would miss the release path. Removing
both guards reproduces the issue verbatim: "attempt to subtract with overflow"
in debug, "index out of bounds: the len is 0 but the index is
18446744073709551615" in release.

Also amended the filtered-estimates spec (#30): the tolerance-not-bit-identity
caveat is conservative. Forcing the scratch onto the sequential sweep instead
of the grouped one — a far larger perturbation than a permuted event order —
still agrees within 1e-8 under tight convergence.

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

src/color_group.rs

@@ -103,7 +103,6 @@ impl ColorGroups {
 /// `Index` values that event touches. The returned `ColorGroups` has one
 /// inner `Vec<usize>` per color, containing event indices in the order
 /// they were assigned.
-#[allow(dead_code)]
 pub(crate) fn color_greedy<I, F>(n_events: usize, index_set: F) -> ColorGroups
 where
     F: Fn(usize) -> I,

src/history.rs

@@ -428,14 +428,28 @@ impl<T: Time, D: Drift<T>, O: Observer<T>, K: Eq + Hash + Clone> History<T, D, O
             .collect()
     }
 
-    pub(crate) fn log_evidence_internal(&mut self, forward: bool, targets: &[Index]) -> f64 {
+    /// Sum per-slice evidence.
+    ///
+    /// `forward` selects `skill.forward` as each event's prior instead of the
+    /// cavity. That is a genuine forward-only (filtering) quantity ONLY on a
+    /// history that has never been converged: `iteration` alternates backward
+    /// and forward sweeps, so from the second iteration onward the likelihood
+    /// feeding the forward message has already absorbed backward information.
+    /// For a filtering quantity that holds after convergence, use
+    /// `filtered_log_evidence`.
+    pub(crate) fn log_evidence_internal(&self, forward: bool, targets: &[Index]) -> f64 {
+        // Bound before the closure so it captures the store rather than all of
+        // `&self`: capturing `&History` would drag `KeyTable<K>` in and demand
+        // `K: Sync` from every caller, which the key type need not satisfy.
+        let agents = &self.agents;
+
         #[cfg(feature = "rayon")]
         {
             use rayon::prelude::*;
             let per_slice: Vec<f64> = self
                 .time_slices
                 .par_iter()
-                .map(|ts| ts.log_evidence(targets, forward, &self.agents))
+                .map(|ts| ts.log_evidence(targets, forward, agents))
                 .collect();
             per_slice.into_iter().sum()
         }
@@ -443,19 +457,19 @@ impl<T: Time, D: Drift<T>, O: Observer<T>, K: Eq + Hash + Clone> History<T, D, O
         {
             self.time_slices
                 .iter()
-                .map(|ts| ts.log_evidence(targets, forward, &self.agents))
+                .map(|ts| ts.log_evidence(targets, forward, agents))
                 .sum()
         }
     }
 
     /// Total log-evidence across the history.
-    pub fn log_evidence(&mut self) -> f64 {
+    pub fn log_evidence(&self) -> f64 {
         self.log_evidence_internal(false, &[])
     }
 
     /// Log-evidence restricted to time slices containing at least one of the
     /// given keys. Useful for leave-one-out cross-validation.
-    pub fn log_evidence_for<Q>(&mut self, keys: &[&Q]) -> f64
+    pub fn log_evidence_for<Q>(&self, keys: &[&Q]) -> f64
     where
         K: std::borrow::Borrow<Q>,
         Q: std::hash::Hash + Eq + ?Sized,

src/time_slice.rs

@@ -305,8 +305,9 @@ impl<T: Time> TimeSlice<T> {
                     *idx,
                     Skill {
                         forward: agents[*idx].receive(&self.time),
+                        backward: N_INF,
+                        likelihood: N_INF,
                         elapsed,
-                        ..Default::default()
                     },
                 );
             }