starkernel: converge the tick path and wire the adaptive heartbeat (item 0.8)

Introduces src/starkernel/heartbeat.c as the shared top/bottom-half
implementation of heartbeat_init/tick/service/ticks/trust/state, replacing
the per-architecture duplicates in amd64/riscv64/aarch64 timer.c. Each
arch's timer.c now contributes only heartbeat_read_counter() (rdtsc /
rdtime / CNTPCT_EL0). Per the GAP-A1 ruling the top half stays counter+
latch only; heartbeat_service() (called every REPL idle iteration,
unconditionally per FABRIC.md's fidelity note) does the window/variance/
trust work outside interrupt context. vm_tick()'s call sites are
unchanged -- the engine still runs on the virtual tick.

Per FABRIC.md §26 (ruled 2026-08-03): wires Loop #7's execution-derived
stable/volatile signal into the physical re-arm period. vm_runtime.c's
existing Loop #7 site now calls heartbeat_set_adaptive_period_ns() with
tick_target_ns ratio-rescaled onto a 10ms kernel base (not the hosted
10us HEARTBEAT_TICK_NS -- see §26.3 for the scale mismatch). Each
architecture's re-arm function (apic_timer_rearm() on amd64/aarch64,
riscv64_timer_rearm()) now converts heartbeat_next_period_ns() to its
own raw counter units instead of a fixed constant; amd64 gained a
rearm function it didn't previously need, since periodic-mode auto-reload
never required one before this item.

Verified: all three architectures build with no new warnings and boot
cleanly to ok> with dict_hash=0x3d4e1daf289da94f, unchanged from the
pre-change baseline -- no regression. Verified NOT achieved: live re-arm
period variation under load. A temporary diagnostic (added and reverted)
confirmed Loop #7 never actually fired during a live QEMU session -- a
synthetic word-execution loop drove ~6,500 executions, past the 1000-tick
inference frequency, without tripping vm_tick_inference_engine()'s
pre-existing !vm->rolling_window.is_warm gate. That gate predates this
item and was not investigated -- out of scope. FABRIC.md's Done-when is
amended to record this honestly rather than claim it.

Punch list §25 item 0.8 complete (per amended, weaker acceptance -- see
the item's own annotation).

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

src/starkernel/repl.c

@@ -16,10 +16,13 @@
  *   - Output: console_puts() / console_putc()
  *
  * Idle spin:  polls console_getc() and services the adaptive heartbeat.
- *             The APIC timer ISR increments heartbeat_ticks() at 100 Hz;
- *             the idle spin calls sk_repl_idle() once per SK_IDLE_BEAT_INTERVAL
- *             ticks.  On QEMU TCG the ISR must fire for ticks to advance —
- *             check "Heartbeat: N ticks" in the serial log to confirm.
+ *             The timer ISR's top half (heartbeat_tick()) latches one
+ *             sample per interrupt; the idle spin drains it every
+ *             iteration via heartbeat_service() (item 0.8, FABRIC.md §26)
+ *             and calls sk_repl_idle() once per SK_IDLE_BEAT_INTERVAL ticks
+ *             for coarser subsystem dispatch. On QEMU TCG the ISR must fire
+ *             for ticks to advance — check "Heartbeat: N ticks" in the
+ *             serial log to confirm.
  *
  * Runs with interrupts enabled so the APIC heartbeat fires normally.
  * Designed as the last thing kernel_main does before the idle loop.
@@ -85,7 +88,15 @@ static int sk_readline(char *buf, int size)
         int c = console_getc();   /* non-blocking poll */
 
         if (c < 0) {
-            /* Idle — service the adaptive heartbeat if a beat has elapsed */
+            /* Service the heartbeat bottom half every idle iteration, not
+             * gated by SK_IDLE_BEAT_INTERVAL (item 0.8, FABRIC.md §26):
+             * heartbeat_service() drains at most one latched sample per
+             * call, so a coarse gate here would silently lose or merge
+             * samples between ISR-latched ticks. sk_repl_idle() below is
+             * a separate, deliberately coarser cadence for higher-level
+             * subsystem dispatch, unrelated to sample fidelity. */
+            heartbeat_service();
+
             uint64_t now = heartbeat_ticks();
             if (now - g_last_beat_tick >= SK_IDLE_BEAT_INTERVAL) {
                 g_last_beat_tick = now;