feat: allow drift to vary per competitor via Member::with_drift_scale

Drift was a property of the History, so every competitor drifted at the
same rate and a fixed reference point could not share a graph with moving
competitors. A bot at a known strength, a rating floor, a course
difficulty — all of them drifted along with the players.

Member::with_drift_scale(s) multiplies the drift *variance* a competitor
accumulates, so s is in the same units as gamma: ConstantDrift(g) at
scale s behaves exactly as ConstantDrift(g * s) would for that competitor.
A scalar rather than a per-competitor Drift keeps History's single D type
parameter untouched and stays Copy. 0.0 pins a competitor still.

The scale lives on Rating, beside the drift it scales, and is applied
only through Rating::drift_variance_delta / drift_variance_for_elapsed.
Making those the sole entry points means a caller cannot reach the raw
drift and silently skip a competitor's scale — the filtered pass was
exactly that bug during development, caught because its test was written
before the wiring.

Like with_prior, the scale is competitor configuration captured at first
appearance rather than a per-event override; a competitor that is static
is static, and a scale that changed between events would make the skill
trajectory hard to interpret. Member's docs claimed prior was a per-event
override, which the code has never done — corrected here.

A negative scale is rejected rather than squared into its absolute value,
and a non-finite one rejected outright, both as InvalidParameter.

None means 1.0, so no existing call site changes and no existing fit
moves. Adding a public field to Member does break struct-literal
construction downstream.

Closes #34

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

README.md

@@ -71,6 +71,36 @@ let h = History::builder()
     .build();
 ```
 
+### Per-competitor drift
+
+A `History` has one drift model, but individual competitors can scale it.
+`Member::with_drift_scale(s)` multiplies the drift *variance* that competitor
+accumulates, so `s` is in the same units as `gamma`: `ConstantDrift(g)` at
+scale `s` behaves exactly as `ConstantDrift(g * s)` would, for that competitor
+alone.
+
+`0.0` pins a competitor still. That is what makes a **fixed reference point**
+expressible in the same graph as moving competitors — a bot at a known
+strength, a rating floor, a course difficulty:
+
+```rust
+let events = vec![Event {
+    time: 0,
+    teams: smallvec![
+        Team::with_members([Member::new("player")]),
+        // A course does not improve. Pin it, and the round's evidence
+        // lands on the player instead of being split between the two.
+        Team::with_members([Member::new("layout_7").with_drift_scale(0.0)]),
+    ],
+    outcome: Outcome::winner(0, 2),
+}];
+```
+
+Like `with_prior`, the scale is **competitor configuration captured at first
+appearance** — setting it on a key the history already knows has no effect. It
+must be finite and non-negative; ingestion otherwise fails with
+`InferenceError::InvalidParameter`.
+
 ## Scored outcomes
 
 Use `Outcome::scores([...])` when you have continuous per-team scores rather