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

tests/game.rs

@@ -155,7 +155,7 @@ mod malformed_games {
         let err = Game::<i64, _>::ranked(&[&[a]], Outcome::winner(0, 1), &GameOptions::default())
             .unwrap_err();
         assert!(
-            matches!(err, InferenceError::NotEnoughTeams { got: 1 }),
+            matches!(err, InferenceError::NotEnoughTeams { got: 1, .. }),
             "{err:?}"
         );
     }
@@ -173,7 +173,7 @@ mod malformed_games {
         )
         .unwrap_err();
         assert!(
-            matches!(err, InferenceError::NotEnoughTeams { got: 1 }),
+            matches!(err, InferenceError::NotEnoughTeams { got: 1, .. }),
             "{err:?}"
         );
     }
@@ -184,7 +184,7 @@ mod malformed_games {
             Game::<i64, ConstantDrift>::ranked(&[], Outcome::ranking([]), &GameOptions::default())
                 .unwrap_err();
         assert!(
-            matches!(err, InferenceError::NotEnoughTeams { got: 0 }),
+            matches!(err, InferenceError::NotEnoughTeams { got: 0, .. }),
             "{err:?}"
         );
     }
@@ -198,7 +198,7 @@ mod malformed_games {
             Game::<i64, _>::ranked(&[&[], &[a]], Outcome::winner(0, 2), &GameOptions::default())
                 .unwrap_err();
         assert!(
-            matches!(err, InferenceError::EmptyTeam { team: 0 }),
+            matches!(err, InferenceError::EmptyTeam { team: 0, .. }),
             "{err:?}"
         );
     }