stadium: wire STADIUM_CAPACITY_TICK in as a flat threshold, not a scheduler

Closes FABRIC-2.md's last open §12 Q5 question. fleet_heartbeat_tick_count
is fed by every live VM's own vm_tick(), not one VM's, so it was reaching
HEARTBEAT_INFERENCE_FREQUENCY (shared/borrowed from the per-VM inference
gate) several times faster than intended with more than one VM live -
backwards from FABRIC.md §22.4's required ~1000:1 separation.

What's actually gated turned out to be low-stakes: vm_physics_tick()
(capsule_vm_physics.c:397) is a passive statistics refit - re-sorts a
window of past heat-transfer samples and recomputes a median rate
estimate. It doesn't move heat or arbitrate capacity. Firing too often
just meant a noisier statistic recomputed more frequently than planned,
not incorrect behavior.

Considered and explicitly rejected: scaling the threshold by live VM
count at the check site. That's the first brick of a scheduler - reading
fleet state to adjust a rate dynamically - which this project has
deliberately avoided building. Implemented instead: STADIUM_CAPACITY_TICK
(existing Kconfig symbol, defined but never read by any code path) now
gates vm_physics_heartbeat_tick()'s call directly, replacing the borrowed
HEARTBEAT_INFERENCE_FREQUENCY. Default bumped 1000 -> 4000, a flat
constant picked once for Tripod's known 4-VM topology, same kind of
placeholder as every other frequency knob in Kconfig.kernel - not
computed from anything at runtime. Renamed fleet_last_inference_tick ->
fleet_last_capacity_tick to match. Still one clock, one counter
(fleet_heartbeat_tick_count) - just a bigger flat divisor on it.

Three-arch QEMU acceptance: all clean to ok>, identical Stadium
conservation invariant on all three (resident_sum=43691 reservoir=21845
sum=65536). logs/20260815-093425/amd64, logs/20260815-093521/aarch64,
logs/20260815-093641/riscv64.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

src/starkernel/capsule/capsule_vm_physics.c

@@ -39,7 +39,7 @@
 #include "starkernel/kmalloc.h"
 #include "starkernel/q48_16.h"
 #include "starkernel/console.h"
-#include "starforth_config.h" /* HEARTBEAT_INFERENCE_FREQUENCY */
+#include "starforth_config.h" /* STADIUM_CAPACITY_TICK */
 #include "starkernel/vm/bootstrap/sk_vm_bootstrap.h" /* sk_get_mama_vm */
 #include "vm.h"           /* VM, vm->ssm_l8_state */
 #include "ssm_jacquard.h" /* ssm_l8_state_t, CDConfigTable */
@@ -155,7 +155,10 @@ static uint64_t slope_fit_quality_q48    = 0;
  * without a forward declaration -- it is now this counter's second
  * reader, alongside vm_physics_heartbeat_tick()'s own gating use. */
 static uint64_t fleet_heartbeat_tick_count  = 0;
-static uint64_t fleet_last_inference_tick   = 0;
+static uint64_t fleet_last_capacity_tick    = 0; /* renamed 2026-08-15 from
+                          fleet_last_inference_tick -- gated on
+                          STADIUM_CAPACITY_TICK now, not HEARTBEAT_
+                          INFERENCE_FREQUENCY, see vm_physics_heartbeat_tick() */
 
 static vm_physics_node_t *vm_physics_find(VMUuid vm_id)
 {
@@ -454,12 +457,22 @@ void vm_physics_tick(uint64_t now_ns)
     fleet_transfer_slope_q48 = (rates[rate_count / 2] * l8_regime_modulation_q16()) >> 16;
 }
 
+/* Gated on STADIUM_CAPACITY_TICK, not HEARTBEAT_INFERENCE_FREQUENCY (fixed
+ * 2026-08-15, FABRIC-2.md §12 Q5): fleet_heartbeat_tick_count is fed by
+ * EVERY live VM's own vm_tick() (see the comment above this counter's
+ * declaration), so it advances several times faster in wall-clock terms
+ * than a single VM's own tick_count -- comparing it against
+ * HEARTBEAT_INFERENCE_FREQUENCY (written assuming a single VM's stream)
+ * meant this fired far more often than §22.4's required ~1000:1 separation
+ * from a VM's own heat-inference loop. Still one clock, one counter --
+ * this is a bigger flat threshold on the same counter, not a second tick
+ * source or anything that reads live VM count to adjust itself. */
 void vm_physics_heartbeat_tick(uint64_t now_ns)
 {
     fleet_heartbeat_tick_count++;
-    if ((fleet_heartbeat_tick_count - fleet_last_inference_tick) >= HEARTBEAT_INFERENCE_FREQUENCY) {
+    if ((fleet_heartbeat_tick_count - fleet_last_capacity_tick) >= STADIUM_CAPACITY_TICK) {
         vm_physics_tick(now_ns);
-        fleet_last_inference_tick = fleet_heartbeat_tick_count;
+        fleet_last_capacity_tick = fleet_heartbeat_tick_count;
     }
 }