fix(v4.0.0): step 6c mended after its review -- what a stuck or gone node can and cannot hold up

The review of step 6c found it did not keep its rule.  Ruled: fix them
all; 16 hops.

- Paying a NACK no longer waits on a lower-numbered neighbour; a node
  that owes one does not sleep, and goes on taking in what it is sent.
- AWAIT looks first through the messages already waiting.
- A node waiting to write to a removed neighbour gets error 18: the
  word that says who is reading also says which ports have anything on
  them.
- A console line lets Hera go when she is blocked on the first word of
  a message (v4_fabric_interrupt_error, a device's `pending`).
- A refused answer is told to the node that waits, not the one that
  answered; one owed to the node itself goes to its own queue.
- A message is passed on by at most 16 nodes, then refused.
- A GONE is believed only when it says it is from the node's centre.
- Tests: the check that tested nothing is replaced; no room for a
  waiting sender; the limit that remains is tested as a limit.
- MESH.md 7b's rule reworded to what holds, 7b.7 says where it falls
  short; README likewise.

make -C v4 test, sanitize, hosted-check; three bare-metal boots.  POST
538 of 538, word_count=317, dict_hash=0xc0769523a47b7dc3 on all six.

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

v4/tests/test_host_unit.c

@@ -140,7 +140,7 @@ static int host_born(void *self)
     v4_node_fault_attach(&pool[k].n, w_fault);
     v4_blocks_init(&node_blocks[k], BUF0_W);
     if (k != 0) {                                    /* Hera's kernel is wired where she is made */
-        node_kernel[k].take = node_kernel_take; node_kernel[k].give = 0; node_kernel[k].self = &pool[k];
+        node_kernel[k].take = node_kernel_take; node_kernel[k].give = 0; node_kernel[k].self = &pool[k]; node_kernel[k].pending = 0;
         if (!v4_fabric_wire_device(&f, (unsigned)place, 0, &node_kernel[k])) return -1;
     }
     return place;
@@ -194,7 +194,7 @@ static int kernel_take(void *self, v4_cell value)       /* a request */
     if (value < FIRST_REQUEST || !v4_manage_serve(&manage, hera_place, (unsigned)(value - FIRST_REQUEST))) refused++;
     return 1;
 }
-static const v4_device kernel = { kernel_take, kernel_give, 0 };
+static const v4_device kernel = { kernel_take, kernel_give, 0, 0 };
 
 /* ---- the console: a device on Hera's port 1 ---- */
 #define CONSOLE_ID 1
@@ -237,7 +237,8 @@ static int console_take(void *self, v4_cell value)
     }
     return 1;
 }
-static const v4_device console = { console_take, console_give, 0 };
+static int console_pending(void *self) { (void)self; return going_at < going.count; }
+static const v4_device console = { console_take, console_give, 0, console_pending };
 
 /* Is there a node that will execute at the next step?  A step in which a
  * node only faulted counts nothing done (exec.h), and it goes on from its
@@ -381,6 +382,7 @@ int main(void)
     /* ---- Hera is born empty, and takes in the nucleus ---- */
     v4_fabric_init(&f, places, PLACES);
     v4_fabric_gone_error(&f, V4_ERROR_NO_ONE);
+    v4_fabric_interrupt_error(&f, V4_ERROR_INTERRUPTED);
     place = host_born(0);
     CHECK(place == 0, "a node is born");
     hera_place = (unsigned)place;
@@ -546,14 +548,28 @@ int main(void)
     }
     step_limit = 30000000ul;
 
+    /* Hera blocked writing to a node that is stuck: a line from the console lets her go (MESH.md 7b.7) */
+    step_limit = 3000000ul;
+    CHECK(strcmp(tell(11, ": SPIN BEGIN 0 UNTIL ; SPIN"), "(still running)") == 0, "node 11 is stuck in a loop");
+    CHECK(strcmp(tell(10, ": T11 S\" 1 DROP\" 11 SEND  67 EMIT ; T11"), "(still running)") == 0 && node_numbered(10)->asking,
+          "Hera sends it text: its number is the higher, so she writes without looking, and is blocked");
+    {
+        const char *r = tell(10, "11 KILL  68 EMIT");
+        CHECK(strstr(r, "Interrupted\n") != NULL && strstr(r, "D") != NULL && strstr(r, "C") == NULL && strstr(r, "Interrupted\n") < strstr(r, "D"),
+              "a line typed at the console ends the line that was blocked, with an error that says so, and is then done: \"%s\"", r);
+        CHECK(node_numbered(11) == NULL && !node_numbered(10)->asking && waiting(10), "the line killed the stuck node, and Hera is back at her ports");
+    }
+    CHECK(strcmp(tell(10, "1 2 + ."), "3 ") == 0, "and she goes on");
+    step_limit = 30000000ul;
+
     /* what is not a node she has had born */
     {
         unsigned born = born_count;
         CHECK(strstr(tell(10, "99 KILL"), "KILL: no such node") != NULL && ended_how == V4_TEXT_ERROR, "KILL of a node there never was is an error that says so: \"%s\"", printed);
         CHECK(strstr(tell(10, "10 KILL"), "KILL: no such node") != NULL && ended_how == V4_TEXT_ERROR && node_numbered(10) != NULL, "so is KILL of Hera herself");
         CHECK(strstr(tell(10, "14 KILL"), "KILL: no such node") != NULL && ended_how == V4_TEXT_ERROR, "and of a node she has killed already");
-        CHECK(born_count == born && node_numbered(11) != NULL && strcmp(tell(11, "11 100 * ."), "1100 ") == 0 && strcmp(tell(10, "1 2 + ."), "3 ") == 0,
-              "nothing was removed, and the two that are left go on");
+        CHECK(born_count == born && strcmp(tell(10, "1 2 + ."), "3 ") == 0,
+              "nothing was removed, and Hera goes on");
     }
 
     printf("  %d checks, %d failures\n", checks, failures);