re(flight): LT mirrors RT, and roll does not depend on speed

One flight, two measurements (flight_law2.py, binding early so the moving-craft scan
can see the player).

LT curve: 436, 379, 289, 209, 126 units/s across LT 0.00 -> 1.00 — a straight ramp,
whose endpoints after the ~1.2 time-base factor are CruisingVelocity 350 and
MinimumVelocity 100. So the law is symmetric:

  RT: target = Cruising + RT * (Maximum - Cruising)
  LT: target = Cruising - LT * (Cruising - Minimum)

Roll (measured on a non-forward matrix row, since roll turns about the forward axis):
~144 deg/s at minimum speed and ~150 at maximum — no speed dependence, where pitch
dropped by a third to a half between the same regimes. After the time-base factor
that is ~121, i.e. AV_Roll_Max 125 in BOTH regimes.

So _Min/_Max does not mean the same thing for every axis: pitch interpolates with
speed, roll appears pinned at Max. A reimplementation applying one rule to all axes
would get low-speed roll wrong by ~60%.

Caveat recorded: the two roll phases were 2 s of settling apart, marginal for a
126 -> 1342 speed change.

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

docs/re/flight-speed-law.md

@@ -159,8 +159,7 @@ endpoints land on the definition's own numbers — 438/1.2 ≈ **365** against
 target speed = CruisingVelocity + RT · (MaximumVelocity − CruisingVelocity)
 ```
 
-with `LT` presumably mirroring it down to `MinimumVelocity` (measured only at full
-deflection so far: ~125 against 100).
+and `LT` mirrors it down to `MinimumVelocity` — **measured**, see below.
 
 **This also refutes a live hypothesis about the afterburner.** Full `RT` producing
 more than `MaximumVelocity` looked like it might *be* the burner; it is not — the
@@ -169,7 +168,57 @@ Full throttle is simply full throttle.
 
 Raw samples: [`captures/throttle-curve-rt.csv`](captures/throttle-curve-rt.csv).
 
-⏳ The `LT` half of the curve is **not measured**: the entity scan that locks onto
-the player needs the craft to be *moving* when it runs (it searches changing position
-triples), and a mission left idling long enough for the craft to slow or die drops
-out of the scan. Bind early, while the craft still has speed.
+(The entity scan that locks onto the player searches *changing* position triples, so
+it only sees the craft while it still has speed — bind early, or a mission left
+idling drops out of the scan entirely and every tool reports "player entity not
+found" while the game is visibly flying.)
+
+---
+
+# `LT` mirrors `RT`, and roll does NOT depend on speed
+
+One flight, both measurements
+([`tools/re-capture/flight_law2.py`](../../tools/re-capture/flight_law2.py)).
+
+## The braking half of the curve
+
+| `LT` | 0.00 | 0.25 | 0.50 | 0.75 | 1.00 |
+|---|---|---|---|---|---|
+| speed | 436 | 379 | 289 | 209 | **126** |
+
+A straight ramp down from cruise to ~126, and dividing by the ~1.2 time-base factor
+the endpoints are the definition's own numbers again — 363 against
+`CruisingVelocity` **350** and 105 against `MinimumVelocity` **100**. So the throttle
+law is symmetric:
+
+```
+RT held:  target = Cruising + RT · (Maximum − Cruising)
+LT held:  target = Cruising − LT · (Cruising − Minimum)
+```
+
+## Roll
+
+Roll turns the craft about its own forward axis, so it has to be measured on a
+different row of the rotation matrix than pitch was:
+
+| phase | rate per 1 s window | mean |
+|---|---|---|
+| minimum speed + full roll | 171 · 103 · 157 | **~144 °/s** |
+| maximum speed + full roll | 140 · 145 · 164 | **~150 °/s** |
+
+**Roll shows no speed dependence** — the two regimes agree inside the noise, where
+pitch dropped by a third to a half between them. Against the definition
+(`AV_Roll_Min` 200, `AV_Roll_Max` 125) the measured ~145 °/s is ~121 after the
+time-base factor, i.e. **the `Max` value in both regimes**.
+
+So the `_Min`/`_Max` pair does *not* mean the same thing for every axis: pitch
+interpolates between them with speed, roll appears pinned at `Max`. A
+reimplementation that applies one rule to all axes would get roll wrong at low
+speed by ~60 %.
+
+🟡 Caveat kept: the roll phases were 2 s of settling apart, which is marginal for a
+full 126 → 1 342 speed change, so "no dependence" is a measurement over a real but
+not perfectly separated pair of regimes.
+
+Raw samples: [`captures/throttle-curve-lt.csv`](captures/throttle-curve-lt.csv) ·
+[`captures/turn-law-roll.csv`](captures/turn-law-roll.csv).