feat!: name the unknown key, expose tail probabilities, flag short fits

Three issues from two downstream consumers, all small, all sharing a
theme: the crate had the information and would not hand it over.

#44 — `UnknownKey { team: 0, member: 0 }` did not say which key. A
consumer upgrading 0.1.2 -> 0.4.1 had every one of 5591 predictions
return this error, fell back to a neutral 0.5, and lost its entire
metadata model for a day. Nothing crashed and nothing logged; it was
found by sweeping an unrelated parameter and noticing the output did not
move. The 0.4.0 change that made unknown keys an error was right — the
error was just too anonymous to act on. It now carries the key's `Debug`
rendering, and its `Display` says what to do about it. The precondition
is documented on every prediction entry point, which the reporter said
would alone have saved the day.

#43 — `cdf` was `pub(crate)`, so a consumer asking "is this competitor
below the cutoff" approximated it with a `mu + z * sigma` band and had no
way to say what confidence any `z` bought. Adds
`Gaussian::probability_below` / `probability_above`. The second is
separate on purpose: `1 - cdf` collapses to exactly zero past ~8.3
sigma, and a stopping rule is evaluated precisely there. Both route
through the survival function added in 0.4.1, so this is visibility
rather than new numerics.

#50 — `ConvergenceReport` was not `#[must_use]`, so the one signal that
a fit stopped short was trivially discarded. It now is, and that
immediately found 78 sites doing exactly that — including this crate's
own ATP example, which was capped at 10 sweeps when the history needs
30. The example now reads the report and says so.

`ITERATIONS = 30` is documented as the floor it is, with the three
measurements to hand: 400 events over 100 competitors already stops
there at ~7e-3 against a 1e-6 tolerance, the ATP example needs 30 at a
much looser one, and a consumer's 2000-node model needs 76 to 161.

BREAKING CHANGE: `InferenceError::UnknownKey` gains a `key` field, and
the prediction methods now require `K: Debug` in order to fill it.

Closes #43, #50. Refs #44 — its third ask, an opt-in `UnknownKeys::Skip`
mode, is a live API question and deliberately not answered here.

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

tests/competitor_config.rs

@@ -64,13 +64,13 @@ fn a_prior_applies_to_a_new_competitor() {
     let mut with = history();
     with.add_events(vec![bout("a", "b", 0, Some(seeded), None)])
         .unwrap();
-    with.converge().unwrap();
+    let _ = with.converge().unwrap();
 
     let mut without = history();
     without
         .add_events(vec![bout("a", "b", 0, None, None)])
         .unwrap();
-    without.converge().unwrap();
+    let _ = without.converge().unwrap();
 
     assert!(
         (skill_of(&with, "a").mu() - skill_of(&without, "a").mu()).abs() > 1.0,
@@ -91,7 +91,7 @@ fn a_prior_applies_to_a_competitor_the_history_already_knows() {
     // "a" now exists. Configuring it here used to do nothing whatsoever.
     late.add_events(vec![bout("a", "b", 1, Some(seeded), None)])
         .unwrap();
-    late.converge().unwrap();
+    let _ = late.converge().unwrap();
 
     let mut never = history();
     never
@@ -100,7 +100,7 @@ fn a_prior_applies_to_a_competitor_the_history_already_knows() {
             bout("a", "b", 1, None, None),
         ])
         .unwrap();
-    never.converge().unwrap();
+    let _ = never.converge().unwrap();
 
     assert!(
         (skill_of(&late, "a").mu() - skill_of(&never, "a").mu()).abs() > 1.0,
@@ -122,7 +122,7 @@ fn a_prior_is_whole_history_scoped_not_per_event() {
         .unwrap();
     late.add_events(vec![bout("a", "b", 1, Some(seeded), None)])
         .unwrap();
-    late.converge().unwrap();
+    let _ = late.converge().unwrap();
 
     let mut early = history();
     early
@@ -131,7 +131,7 @@ fn a_prior_is_whole_history_scoped_not_per_event() {
             bout("a", "b", 1, Some(seeded), None),
         ])
         .unwrap();
-    early.converge().unwrap();
+    let _ = early.converge().unwrap();
 
     let (l, e) = (skill_of(&late, "a"), skill_of(&early, "a"));
     assert!(
@@ -150,7 +150,7 @@ fn repeating_the_same_prior_is_inert() {
         bout("a", "b", 1, None, None),
     ])
     .unwrap();
-    once.converge().unwrap();
+    let _ = once.converge().unwrap();
 
     let mut every_time = history();
     every_time
@@ -159,7 +159,7 @@ fn repeating_the_same_prior_is_inert() {
             bout("a", "b", 1, Some(seeded), None),
         ])
         .unwrap();
-    every_time.converge().unwrap();
+    let _ = every_time.converge().unwrap();
 
     let (o, e) = (skill_of(&once, "a"), skill_of(&every_time, "a"));
     assert!(
@@ -203,7 +203,7 @@ fn setting_one_field_late_leaves_the_other_alone() {
     // Only the scale this time — the prior above must survive.
     h.add_events(vec![bout("a", "b", 1, None, Some(0.5))])
         .unwrap();
-    h.converge().unwrap();
+    let _ = h.converge().unwrap();
 
     let mut both_upfront = history();
     both_upfront
@@ -212,7 +212,7 @@ fn setting_one_field_late_leaves_the_other_alone() {
             bout("a", "b", 1, None, None),
         ])
         .unwrap();
-    both_upfront.converge().unwrap();
+    let _ = both_upfront.converge().unwrap();
 
     let (a, b) = (skill_of(&h, "a"), skill_of(&both_upfront, "a"));
     assert!(