fix!: correct eight wrong # Errors sections and seal the error variants

Documentation (#78). Every item below was measured against the code
rather than read:

- `expected_information_gain` and `predict_ranking` had `# Errors`
  immediately followed by `# Preconditions`, with the error list stranded
  at the bottom of the latter — rustdoc rendered a BLANK Errors section on
  both. The heading now sits with its content.
- `predict_outcome`, `predict_ranking` and the free
  `expected_information_gain` all omitted `GridTooCoarse`.
- `predict_margin` claimed `JointUnavailable` "if the LATEST slice holds
  ranked events". Measured with an early ranked slice and a late scored
  one: it fails. The condition is *any* slice.
- `add_events` documented three errors and can return five more; it also
  claimed a weights `MismatchedShape` that is unreachable through it,
  since weights arrive one-per-`Member`. That check belongs to
  `EventBuilder::weights`, and the doc now says so.
- `converge` and `converge_partial` both omitted the drift-variance
  `InvalidParameter`.

`History` gains a hand-written `Debug` (#76). Summarising, not
exhaustive — a derived one would print every competitor's skill at every
slice. It exists because without it a consumer cannot `#[derive(Debug)]`
on any struct holding a `History`, which is how both known consumers
store one.

`#[non_exhaustive]` on all 17 `InferenceError` struct variants and on
`Outcome::Scored` (#74). The enum carried the attribute; no variant did,
so adding a field to any of them — and downstream construction of any of
them — were both in the public contract. This crate added two variants in
two days.

The options structs are deliberately NOT sealed. `ConvergenceOptions` and
`GameOptions` are constructed by struct literal at 65 sites of which only
8 use `..default()`, and specifying all three convergence fields is a
natural complete statement rather than a partial one. That is a real
trade-off rather than an oversight, and it is left as a decision on #74.

Also spells `UnknownKeys::Reject` explicitly at both sites that
wildcarded it. `#[non_exhaustive]` on your own enum gives no exhaustiveness
safety net if you then match `_`.

Sealing the variants pushed ten test sites from constructing errors to
`matches!`, which is the better assertion anyway — an `assert_eq!` against
a constructed error breaks whenever a field is added, which is the exact
fragility the attribute exists to prevent.

BREAKING CHANGE: `InferenceError`'s struct variants and `Outcome::Scored`
are `#[non_exhaustive]` — downstream patterns need `..` and downstream
construction is no longer possible.

Refs #78, #76, #74

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

src/error.rs

@@ -43,26 +43,31 @@ pub enum UnknownKeys {
 #[non_exhaustive]
 pub enum InferenceError {
     /// Expected and actual lengths of some array-shaped input differ.
+    #[non_exhaustive]
     MismatchedShape {
         kind: &'static str,
         expected: usize,
         got: usize,
     },
     /// An `Outcome` of the wrong variant was supplied for the requested inference.
+    #[non_exhaustive]
     WrongOutcomeKind {
         context: &'static str,
         expected: &'static str,
         got: &'static str,
     },
     /// A probability value is outside `[0, 1]`.
+    #[non_exhaustive]
     InvalidProbability { value: f64 },
     /// A scalar parameter is outside its valid range.
+    #[non_exhaustive]
     InvalidParameter { name: &'static str, value: f64 },
     /// An event contains tied teams, but the draw probability is zero.
     ///
     /// A zero draw probability asserts that draws cannot occur, so a tied
     /// result has no representable likelihood. Configure a positive `p_draw`
     /// (via `HistoryBuilder::p_draw` or `GameOptions::p_draw`) to admit ties.
+    #[non_exhaustive]
     TieWithoutDrawProbability { teams: (usize, usize) },
     /// The convergence sweep hit `max_iter` with the step still above
     /// `epsilon`.
@@ -77,6 +82,7 @@ pub enum InferenceError {
     /// oscillating rather than converging, in which case `alpha < 1.0` damps
     /// the within-game EP loop. [`History::converge_partial`](crate::History::converge_partial)
     /// returns the short fit instead when that is genuinely what is wanted.
+    #[non_exhaustive]
     NotConverged {
         iterations: usize,
         final_step: (f64, f64),
@@ -86,6 +92,7 @@ pub enum InferenceError {
     ///
     /// Indicates numerical breakdown; the resulting skills are meaningless
     /// and must not be treated as a converged estimate.
+    #[non_exhaustive]
     NonFiniteResult {
         context: &'static str,
         step: (f64, f64),
@@ -99,6 +106,7 @@ pub enum InferenceError {
     /// "last one wins" would make the result depend on iteration order.
     /// Declaring the same value repeatedly is fine and is the expected shape
     /// when a competitor's configuration is a property of the domain.
+    #[non_exhaustive]
     ConflictingCompetitorConfig {
         competitor: usize,
         field: &'static str,
@@ -113,6 +121,7 @@ pub enum InferenceError {
     /// `UnknownKey { team: 0, member: 0 }` learns nothing about *which* of its
     /// keys the history has not seen, and the natural handling — fall back to a
     /// neutral value — turns the whole thing into a plausible constant.
+    #[non_exhaustive]
     UnknownKey {
         team: usize,
         member: usize,
@@ -128,8 +137,10 @@ pub enum InferenceError {
     ///
     /// To change an existing competitor's configuration, supply it on an event
     /// through `Member`; that refits the whole history.
+    #[non_exhaustive]
     AlreadyRegistered { key: String },
     /// A prediction was given a team with no members.
+    #[non_exhaustive]
     EmptyTeam { team: usize },
     /// The prediction grid cannot resolve the narrowest feature in the matchup.
     ///
@@ -147,6 +158,7 @@ pub enum InferenceError {
     /// `predict_win_probabilities` answers the same matchup through adaptive
     /// quadrature and is accurate here; use it when only the per-team win
     /// probabilities are needed.
+    #[non_exhaustive]
     GridTooCoarse {
         /// Nodes required to resolve the narrowest feature.
         needed: usize,
@@ -154,8 +166,10 @@ pub enum InferenceError {
         max: usize,
     },
     /// A joint posterior was requested where one cannot be formed exactly.
+    #[non_exhaustive]
     JointUnavailable { reason: &'static str },
     /// Fewer than two teams were supplied to a prediction.
+    #[non_exhaustive]
     NotEnoughTeams { got: usize },
     /// The full outcome distribution was requested for too many teams.
     ///
@@ -165,6 +179,7 @@ pub enum InferenceError {
     /// enumerate on a caller's behalf; ask for individual rankings with
     /// `predict_ranking`, or for `predict_win_probabilities`, both of which
     /// stay cheap at any team count.
+    #[non_exhaustive]
     TooManyTeams { got: usize, max: usize },
 }