feat(v4.0.0): a node asks its kernel by a blocking write to its port

ENGINE.md step 2, the carrier.  Ruled 2026-10-05 (V3-PARITY.md 1i), on
DECOMPOSITION.md section 6: a write to a port blocks until the neighbour
reads.

- node: v4_node_port_attach, v4_node_port_served; a store to the port keeps
  the value as the request and blocks the node
- exec: a blocked node executes nothing; served, it goes on from the opcode
  after the store, in the same instruction word; a fault meanwhile abandons
  the rest of the word
- compile.v4: n KERNEL-WORD name makes a word whose body writes n to the
  port; its arguments and results are on the data stack
- boot: the kernel's words are made by handing the node text, and requests
  are served between the node's opcodes; one no one serves is error 12
- BYE, the first kernel word: hosted it leaves the program, as hosted v3;
  on the lone node it is v3's cold restart
- ENGINE.md 3a: multiuser, multitasking, preemptive and cooperative, and
  what that asks of the engine

Verified: make -C v4 test passes at both widths, with tests/test_port.c;
hosted-check passes on three ISAs; clean qemu with STARFORTH_V4=1 on amd64,
aarch64 and riscv64 passes POST with the same hashes as hosted, and a
kernel word no one serves and BYE typed at each prompt are answered
(logs/20261005-185506, -185734, -190101; -185234 is an amd64 run in which
those two lines were not typed).

Not done: v3's own C functions serving a node.

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

v4/README.md

@@ -59,19 +59,20 @@ State, 2026-10-05, after `ENGINE.md` step 1: all six builds start the nucleus,
 load `v4:forth79.4th`, pass POST and reach `ok>`, with the same lines:
 
 ```
-PARITY:V4_NUCLEUS words=295 image_hash=0x3b5a9a7a2f7c5361
-PARITY:V4_CAPSULE name=v4:forth79.4th capsule_id=... dict_hash=0xc45c4db43ea0b1f1
+PARITY:V4_NUCLEUS words=296 image_hash=0x736921433a2e0e97
+PARITY:V4_CAPSULE name=v4:forth79.4th capsule_id=... dict_hash=0x01a3a48159f28a3e
 PARITY:V4_POST tests=550 pass=550 fail=0
-PARITY:V4_CAPSULE name=v4:post79.4th capsule_id=... dict_hash=0x88df0873060da73e
+PARITY:V4_CAPSULE name=v4:post79.4th capsule_id=... dict_hash=0x212b7b70848080e7
 PARITY:OK
 POST: PASSED
 ok>
 ```
 
-Bare-metal logs: `logs/20261005-180922/amd64/`, `logs/20261005-181152/aarch64/`,
-`logs/20261005-181541/riscv64/`. On each, three lines were then typed at the
+Bare-metal logs: `logs/20261005-185506/amd64/`, `logs/20261005-185734/aarch64/`,
+`logs/20261005-190101/riscv64/`. On each, six lines were then typed at the
 prompt through the serial port — a definition, its use with the capsule's
-`U*`, and an unknown word — and each answered as the hosted binary does. The
+`U*`, an unknown word, a kernel word no one serves, and `BYE` — and each
+was answered as the hosted binary answers it. The
 capsules were unsigned (no signing key on this machine).
 
 **A node is handed a line** (`docs/v4.0.0/ENGINE.md` 3.1). It does not read
@@ -84,10 +85,19 @@ may be 1024 characters, a block. `v4_line_begin`, `v4_line_done` and
 `v4_boot_line` (`v4/system/boot.c`) is the one loop the hosted binary, the
 kernel and the capsule loader all run it with.
 
+**A node asks its kernel by writing to its port** (`ENGINE.md` 3.3). The
+write blocks the node until it has been served. A kernel word is a
+dictionary entry made by `n KERNEL-WORD name`, whose body writes `n` to the
+port; its arguments and results are on the data stack. `BYE` is the one
+kernel word so far. A node can be stopped between any two instruction
+words and is blocked while it waits at its port, which is what a system of
+many users and tasks, preemptive and cooperative, needs of it
+(`ENGINE.md` 3a).
+
 **This is still the lone node.** On bare metal `kernel_main.c` starts it
 before the fleet tables, beside the kernel's own system and not in the VM's
-place. `ENGINE.md` sets out the steps from here; step 1 is the only one
-done. `V3-PARITY.md` records the rulings it is built from.
+place. `ENGINE.md` sets out the steps from here; step 1 is done and step 2 is
+part done. `V3-PARITY.md` records the rulings it is built from.
 
 **What this does not yet show.** `forth79.4th` holds two definitions, `U*`
 and `U/MOD`. Every other word is still in the assembled nucleus, so POST is