feat(v4.0.0): hosted golden model, single node

First code for StarForth v4 (JUSTIFICATION.md section 10, step 1): one node
of the 32-instruction core as a C99 model, with cell width as a build
parameter.

- Node: P, A, B, F18 circular stacks (10 and 9 deep, D-2), word-addressed
  memory (D-1), 5% guard bands on every bounded list.
- Instruction word: six 5-bit slots in 32 bits at every cell width.
- Executor: all 32 opcodes of DECOMPOSITION.md 1.3. Cell arithmetic wraps
  explicitly; no signed overflow or implementation-defined shift.
- Heat: per-opcode and per-call-target counters and the anti-clock, driven
  by instruction retirement (1.4, D-6 interim).
- Slot packer and runner for tests, and a reference unsigned multiply in
  plain C99 with no 128-bit type.

Tests run at 32- and 64-bit cells, and under ASan and UBSan. They cover
every opcode and execute the first section 4 definitions (NIP SWAP OR
NEGATE ROT 0< 0= 2DUP - U<) against the C operation each stands for.

UM* as written in section 4 is exact only while u1 <= 2^(n-2). Two known
failing cases are pinned in test_foundation.c until it is rewritten.

DECOMPOSITION.md: record D-9, the instruction word is 32 bits at every
cell width (ruled 2026-10-02).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

v4/src/stack.c

@@ -0,0 +1,107 @@
+/* stack.c -- F18 circular hardware stacks.
+ *
+ * The two decompositions (T/S + 8-ring, R + 8-ring) are exactly equivalent to
+ * flat circular buffers of depth 10 and 9 respectively.  The argument, since
+ * the ISA is specified in terms of the decomposition and the differential
+ * test in tests/test_stack.c is written against the flat form:
+ *
+ * Data stack, 10 deep.  Read the stack top to bottom as
+ *
+ *     T, S, ring[(head-1) mod 8], ring[(head-2) mod 8], ..., ring[head mod 8]
+ *
+ * -- that is, ring[(head-1) mod 8] sits immediately below S, and head names
+ * the oldest slot.  push(x) does ring[head]=S; S=T; T=x; head=(head+1) mod 8,
+ * which appends at the top and rotates the oldest entry into the ring.
+ * pop() takes T, promotes S, and pulls ring[(head-1) mod 8] up into S while
+ * stepping head back one -- so the element that was third becomes second and
+ * the ring is re-seated one position earlier.  That is a 10-slot circular
+ * buffer whose slot 0 is T and slot 1 is S, and the head arithmetic is
+ * bookkeeping for which ring slot is oldest.
+ *
+ * Return stack, 9 deep, same argument with one register instead of two: the
+ * stack reads R, ring[(head-1) mod 8], ..., ring[head mod 8].
+ *
+ * "No overflow or underflow; pushing past the bottom silently overwrites the
+ * oldest entry" (D-2) is not an extra rule here -- it is what a fixed-depth
+ * circular buffer with no bounds check does on its own, once the pointer is
+ * allowed to wrap.  Nothing below tests head against anything.
+ */
+#include "v4/stack.h"
+
+void v4_dstack_reset(v4_dstack *st)
+{
+    st->t = 0;
+    st->s = 0;
+    st->head = 0;
+    for (unsigned i = 0; i < V4_DATA_RING; i++) st->ring[i] = 0;
+    v4_guard_fill(st->guard_head, V4_DATA_BOUND, V4_GUARD_PATTERN_HEAD);
+    v4_guard_fill(st->guard_tail, V4_DATA_BOUND, V4_GUARD_PATTERN_TAIL);
+}
+
+int v4_dstack_guards_intact(const v4_dstack *st)
+{
+    return v4_guard_intact(st->guard_head, V4_DATA_BOUND, V4_GUARD_PATTERN_HEAD)
+        && v4_guard_intact(st->guard_tail, V4_DATA_BOUND, V4_GUARD_PATTERN_TAIL);
+}
+
+void v4_dstack_push(v4_dstack *st, v4_cell x)
+{
+    st->ring[st->head] = st->s;
+    st->s = st->t;
+    st->t = x;
+    st->head = (st->head + 1u) % V4_DATA_RING;
+}
+
+v4_cell v4_dstack_pop(v4_dstack *st)
+{
+    v4_cell x = st->t;
+    st->t = st->s;
+    st->head = (st->head + V4_DATA_RING - 1u) % V4_DATA_RING;
+    st->s = st->ring[st->head];
+    return x;
+}
+
+v4_cell v4_dstack_peek(const v4_dstack *st)
+{
+    return st->t;
+}
+
+v4_cell v4_dstack_peek2(const v4_dstack *st)
+{
+    return st->s;
+}
+
+void v4_rstack_reset(v4_rstack *st)
+{
+    st->r = 0;
+    st->head = 0;
+    for (unsigned i = 0; i < V4_RET_RING; i++) st->ring[i] = 0;
+    v4_guard_fill(st->guard_head, V4_RET_BOUND, V4_GUARD_PATTERN_HEAD);
+    v4_guard_fill(st->guard_tail, V4_RET_BOUND, V4_GUARD_PATTERN_TAIL);
+}
+
+int v4_rstack_guards_intact(const v4_rstack *st)
+{
+    return v4_guard_intact(st->guard_head, V4_RET_BOUND, V4_GUARD_PATTERN_HEAD)
+        && v4_guard_intact(st->guard_tail, V4_RET_BOUND, V4_GUARD_PATTERN_TAIL);
+}
+
+void v4_rstack_push(v4_rstack *st, v4_cell x)
+{
+    st->ring[st->head] = st->r;
+    st->r = x;
+    st->head = (st->head + 1u) % V4_RET_RING;
+}
+
+v4_cell v4_rstack_pop(v4_rstack *st)
+{
+    v4_cell x = st->r;
+    st->head = (st->head + V4_RET_RING - 1u) % V4_RET_RING;
+    st->r = st->ring[st->head];
+    return x;
+}
+
+v4_cell v4_rstack_peek(const v4_rstack *st)
+{
+    return st->r;
+}