feat(v4.0.0): a node is sent text as a message and sends back what it prints

MESH.md step 3.  The ports are the transport; the message is what is
transported: to, from, type, heat and TTL, ACL tag, sequence, length, then
text four characters to a word.

- quit.v4: a node with nothing to do is blocked reading "any port"; text
  for it is interpreted; (FINISH) sends what it printed and then how the
  text ended, and it waits again
- core.v4: EMIT keeps what is printed, (FLUSH-OUT) and (HDR) send it to the
  sender on the port the message came on.  EMIT still needs one free data
  cell and no more; it works on the return stack and in A and B
- message.h/.c: the same format for whatever is on a port and is not a node
- boot.c: the boot is the node's console on port 1 and its kernel on port 0
- the prompt tests are a console that speaks messages
- gone: v4_line_begin, v4_line_done, v4_line_status; writing a node's input
  buffer and setting its P from outside; any use of CONSOLE-TX

Verified: make -C v4 test (test_host_quit.c 1283 checks, the full-stack
figures unchanged) and make -C v4 sanitize pass; hosted-check passes on
three ISAs with POST 550 of 550; clean qemu with STARFORTH_V4=1 passes POST
and answers lines typed at each prompt on amd64, aarch64 and riscv64
(logs/20261006-110551, -111621, -111341).  -110837 is an aarch64 run ended
by the test wrapper's limit while still in UEFI firmware; it shows nothing
about v4.

Not done: KEY, EXPECT and QUERY still read the console's input registers;
a message not for this node is let go (step 4).

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

v4/capsule/core.v4

@@ -5,7 +5,8 @@
 \ written here as text for the text assembler (v4/include/v4/text.h).
 \
 \ Constants the loader supplies:  N-1 (cell bits - 1), NODE-ERROR, CONSOLE-TX,
-\ CONSOLE-RX, CONSOLE-STATUS, BASE, (EMIT-HOOK).
+\ CONSOLE-RX, CONSOLE-STATUS, BASE, (EMIT-HOOK), (MSG), (REPLY), (ME), (OUT),
+\ (OUT^).
 \
 \ ERRORS (D-18).  A word that finds an error takes its arguments off the stack
 \ and stores a code in NODE-ERROR.  On a node with a prompt that store is a
@@ -91,16 +92,63 @@ header CMOVE
   DONE: drop drop drop ;
 
 \ ---- section 5.10: the console -------------------------------------------
-\ EMIT sends the character to the console, unless (EMIT-HOOK) holds the xt
-\ of a word: then that word is given it instead ( c -- ), and returns to
-\ EMIT's caller.  Everything the node prints goes through EMIT, so a hook
-\ sees all of it.  The prompt takes the hook off at the end of every line
-\ (quit.v4), so that nothing can leave the console silent.  POST uses it
-\ to compare what a case prints (docs/v4.0.0/NUCLEUS.md 6.3).
+\ ---- what a node prints (docs/v4.0.0/MESH.md section 6) ------------------------
+\ A node has no console of its own.  It does what a message asks, and what
+\ it prints while doing it goes back, as a message, to whoever sent that one,
+\ on the port it came on.  A message is seven words and then its text, four
+\ characters to a word:
+\     to, from, type, heat and TTL, ACL tag, sequence, length in characters
+\ The types:  1 text to be interpreted   2 what a node printed   3 how the
+\ text ended (one word of text: 0 QUIT, 1 completed, 2 an error).
+\ The header of the message being served is in the seven cells (MSG); (REPLY)
+\ is the address of the port it came on; (ME) is this node's number.
+\
+\ Characters are kept in (OUT), 256 of them, a character to a cell, and sent
+\ when it is full and when the text has been done with (quit.v4).  (OUT^)
+\ is where the next goes.
+\
+\ THE STACK.  What prints may be run with the data stack all but full: EMIT
+\ has always needed one free cell and no more, and still does -- it keeps
+\ the character and A on the return stack while it works.  Sending needs
+\ two.
+
+\ ( type -- )   the first six words of a message to the sender of the one
+\ being served; its length, and its text, are the caller's to send.  Each
+\ write waits for the neighbour to take it.  B is left at the port.
+: (HDR)
+  (REPLY) a! @ b!
+  (MSG)+1 a! @ !b                        \ to
+  (ME) a! @ !b                           \ from
+  !b                                     \ type
+  0 !b  0 !b  0 !b ;                     \ heat and TTL, ACL tag, sequence: carried, not used yet
+
+\ ( -- )   send what has been printed: its length, then its characters, four
+\ to a word, the first lowest
+: (FLUSH-OUT)
+  (OUT^) a! @  (OUT) xor if NONE  drop
+  2 (HDR)
+  (OUT^) a! @  (OUT) -  dup !b
+  3 + 2/ 2/  -1 +  (OUT) a!
+  FOR  @+  @+ 8* +  @+ 8* 8* +  @+ 8* 8* 8* +  !b  NEXT
+  (OUT) (OUT^) a! ! ;
+  NONE: drop ;
+
+\ EMIT puts the character with what has been printed, unless (EMIT-HOOK)
+\ holds the xt of a word: then that word is given it instead ( c -- ), and
+\ returns to EMIT's caller.  Everything the node prints goes through EMIT,
+\ so a hook sees all of it.  The hook is taken off when the text being
+\ interpreted ends (quit.v4), so that nothing can leave a node silent.
+\ POST uses it to compare what a case prints (docs/v4.0.0/NUCLEUS.md 6.3).
+\ A is kept: the words that print have always been free to use it across
+\ an EMIT.  As v3, only the low 8 bits of the character are printed.
 header EMIT
 : EMIT ( c -- )
   (EMIT-HOOK) b! @b  if NONE  push ;
-  NONE: drop  CONSOLE-TX b! !b ;
+  NONE: drop
+  255 and  a push  push                  \ A, and then the character, to the return stack
+  (OUT^) b! @b a!  pop !+  a !b          \ the character goes where (OUT^) points, which moves on
+  a (OUT)+256 xor if FULL  drop  pop a! ;
+  FULL: drop  (FLUSH-OUT)  pop a! ;
 header KEY
 : KEY  ( -- c )
   L: CONSOLE-STATUS b! @b  if WAIT  drop  CONSOLE-RX b! @b ;