Ablation: the radial TM is replaceable by a CONSTANT, and its avenue is dead on the

shipped metric

The radial TM beats Linear on bmPoint, but its head never beat the majority
baseline after the label bias was fixed - suggesting the win is a constant lean
rather than learning. So: sweep a stateless constant short-range offset (new
`common_libs/guns/radial_offset.nim`, no learning at all) against the learned TM.

VERDICT (measured, offline range, seeds=3, 18 paired runs, 231 TM rounds):
1. **bmPoint - REPLACE the TM with a constant.** `RO_s0.95` (aim distance x0.95)
   TIES it early (9/9, p=1.0) and BEATS it overall (15/3, p=0.0075; 7.47% vs
   6.89% per-run mean). A fixed -20px does the same. The head never beats its
   majority baseline (56.2% vs 57.2%).
2. **bmPath (the SHIPPED metric) - the radial avenue is a DEAD END.** TMRadial is
   a systematic LOSS there (2/16, p=0.0013); every constant is within +-0.2pp; the
   only real bmPath effect is the BotRadius clamp. So the radial shift cannot help
   the shipped configuration.
3. The per-adversary optimum DOES vary (fixed -10 for crazy, -30 for tr_crazy,
   scale 0.95 for three others) - but ONE GLOBAL CONSTANT still beats the
   adaptively-trained head, so the "fragility justifies learning" argument FAILS.

THE REAL FINDING UNDERNEATH, and it generalises beyond this gun: the base linear
prediction systematically OVERSHOOTS. Measured raw per-tick base radial error has
mean -71 to -100 px; the enemy is NEARER than the prediction in 63-81% of shots
and farther in only 4-14%, CONSISTENT ACROSS ALL SIX CAPTURES. Radial label
histogram [415166,126461,120325,44694,19351] = 57.2% majority class, mean label
-82.3 px, mean applied shift -37.6 px. So the net-short bias is a GENUINE property
of these range-holders against a constant-velocity extrapolation (they decelerate
and turn, so the true position is closer than the straight-line guess) - NOT a
fixture artefact. That is worth chasing for the guns that actually ship.

Caveat: bmPoint is not the shipped metric (bmPath won the real-hit-rate A/B for
SELECTION), so a bmPoint win is not yet evidence of a real win. That needs a live
test - and the natural target is Pattern, which is now the default and best gun.

Adds radial_offset.nim + sweep_radial_offset.nim; tm_pattern.nim gains additive
instrumentation only (radial label mean and applied-shift mean; no behaviour
change, and test_tm_pattern_registration still passes all 20 checks).

common_libs/guns/radial_offset.nim

@@ -0,0 +1,55 @@
+## Constant-offset radial gun — the ABLATION CONTROL for `guns/tm_pattern.nim`'s
+## radial head.
+##
+## Why this exists: the radial Tsetlin head was shown to win on `bmPoint` not by
+## out-classifying a majority baseline (its online accuracy sits AT/BELOW the
+## majority-class rate) but — per its own committed write-up — because the net
+## applied radial correction is a positive average shift of the aim distance. If
+## that is true, a FIXED radial shift should reproduce most or all of the win
+## with no learning, no 0.36 ms/tick cost and no risk.
+##
+## This gun is that fixed shift, and nothing else:
+##
+##   base   = `forecastLinear` — the exact self-consistent forecast `LinearGun`
+##            and the TM base use.
+##   aim    = the base BEARING unchanged; the aim DISTANCE scaled by `scale` and
+##            shifted by `offsetPx`:
+##              aimDist = f.dist * scale + offsetPx
+##   clamp  = the SAME `[BotRadius, arena-BotRadius]` clamp the TM's corrective
+##            (non-base) path uses, so this is byte-comparable with TMRadial.
+##
+## `scale == 1.0 and offsetPx == 0.0` is the pure base through the corrective
+## clamp — useful as a clamp-only diagnostic against `LinearGun`'s `[0, arena]`.
+## There is NO learning, no history and no per-tick state: two runs on the same
+## state stream are identical by construction.
+
+import std/math
+import gun_harness/gun_interface
+import guns/lead_forecast
+
+type
+  RadialOffsetGun* = object
+    scale*:    float  ## multiplicative factor on the base fire distance
+    offsetPx*: float  ## fixed px added to the base fire distance (negative = short)
+    debugGraphics*: bool
+
+proc initRadialOffsetGun*(scale = 1.0, offsetPx = 0.0): RadialOffsetGun =
+  RadialOffsetGun(scale: scale, offsetPx: offsetPx)
+
+proc predict*(g: var RadialOffsetGun, state: WorldState,
+              bulletSpeed: float): GunPrediction =
+  if bulletSpeed <= 0.0:
+    return GunPrediction(x: state.enemyX, y: state.enemyY)
+  let f = forecastLinear(state, bulletSpeed)
+  let aimDist = f.dist * g.scale + g.offsetPx
+  let px = state.selfX + cos(f.bearing) * aimDist
+  let py = state.selfY + sin(f.bearing) * aimDist
+  # Mirror the TM's corrective path exactly (TMRadial when radOffset != 0):
+  # same bearing, adjusted distance, BotRadius-inset clamp.
+  GunPrediction(
+    x: clamp(px, BotRadius, state.arenaWidth - BotRadius),
+    y: clamp(py, BotRadius, state.arenaHeight - BotRadius),
+  )
+
+proc onResult*(g: var RadialOffsetGun, e: FeedbackEvent) =
+  discard  # analytical, stateless — the ablation has no learning by design

common_libs/guns/tm_pattern.nim

@@ -179,6 +179,13 @@ type
     revLabelHist*:  array[2, int]
     radCorrect*, radTotal*: int
     revCorrect*, revTotal*: int
+    ## Radial-target instrumentation (ablation support): raw label statistics
+    ## and the mean APPLIED aim-distance shift, so a constant-offset control can
+    ## be compared against the actual average readout the TM produces.
+    radDeltaSum*, radDeltaAbsSum*: float
+    radDeltaN*: int
+    radOffsetSum*: float
+    radOffsetN*: int
     classCorrect*: int   ## warm predictions whose class matched the eventual label
     classTotal*:   int   ## warm predictions with a resolvable label
     lastChosen*: int
@@ -502,6 +509,9 @@ proc tmResolveTrace(g: var TmPatternGun, t: TmPatternTrace, power: float) =
   # distance. Independent of our own aim, so it is a clean target.
   let actualRadius = hypot(g.posRing[s].x - t.fireX, g.posRing[s].y - t.fireY)
   let radDelta = actualRadius - t.fireDist
+  inc g.radDeltaN
+  g.radDeltaSum += radDelta
+  g.radDeltaAbsSum += abs(radDelta)
   let radWinner = if shuffleRad: rand(TM_CLASSES - 1) else: radToBucket(radDelta)
   inc g.radLabelHist[radWinner]
   if t.warm:
@@ -612,6 +622,8 @@ proc predict*(g: var TmPatternGun, state: WorldState, bulletSpeed: float):
       else: gf = TM_SHRINK * bucketToGF(chosen)
     of tmRadial:
       radOffset = bucketToRadial(radChosen)
+      g.radOffsetSum += radOffset
+      inc g.radOffsetN
     of tmReversal:
       if TM_GF_MODE == "soft": gf = TM_SHRINK * tmSoftGF(votes)
       else: gf = TM_SHRINK * bucketToGF(chosen)