feat(v4.0.0): the prompt -- QUIT, ABORT, ABORT" and ."

Layer 5 of the compiler capsule.  The host node is now started at QUIT and
left running: it prompts, reads a line from its console with QUERY,
interprets it, says " ok" or " ERROR", and goes round again.

- capsule/quit.v4: QUIT and ABORT (FORTH-79), ABORT" and (ABORT") as v3 has
  them, ." and (.") (FORTH-79).  Text is compiled as a counted string after
  the call; the run-time word returns to the cell after it.
- INTERPRET prints v3's messages before abandoning a line:
  UNKNOWN WORD: 'xxx' and xxx: compile-only.
- core.v4: CR SPACE COUNT TYPE, as DECOMPOSITION.md gives them.
- input.v4: WORD split so that (PARSE) can take text without skipping
  leading delimiters (." " is an empty string); EXPECT keeps its place in
  memory, so six values may wait on the stack while a line is typed.
- tests/test_host_quit.c: the node is fed characters and its output read;
  16 sessions are transcripts of the v3 binary.

QUIT stops the line from inside any word and says nothing; v3's goes on
with the line and cannot be compiled.  v3's compiled ABORT" crashes.

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

v4/capsule/input.v4

@@ -27,17 +27,24 @@ header SOURCE
 \ must hold n + 1 bytes.  No action for n <= 0.  SPAN is how many characters
 \ were stored (SPAN is not FORTH-79; v3 has it).  A line longer than n leaves
 \ the rest, its new-line included, to be read next.
+\ It is what the prompt reads every line with, with whatever the user has left
+\ on the stack beneath it, so it works in (P) -- (P)+0 where the next
+\ character goes, (P)+1 how many more may come, (P)+2 where the first went --
+\ and has at most three cells of its own on the data stack (D-2).
 header EXPECT
 : EXPECT
   -if NN  drop drop ;                        \ n < 0
   NN: if ZERO
-  over push                                  \ p n        R: start
-  L: if END
-     push  KEY  dup -10 + if NL              \ p c x      R: start n
-     drop over C!  1 +  pop -1 +  jump L
-     NL: drop drop pop
-  END: drop  0 over C!                       \ p
-       pop -  SPAN a! ! ;
+  (P)+1 a! !  dup (P)+2 a! !  (P) a! !
+  L: (P)+1 a! @ if END  drop
+     KEY  dup -10 + if NL  drop              \ c
+     (P) a! @ C!
+     (P) a! @ 1 + !  (P)+1 a! @ -1 + !
+     jump L
+     NL: drop drop  jump FIN
+  END: drop
+  FIN: 0 (P) a! @ C!
+       (P) a! @  (P)+2 a! @  -  SPAN a! ! ;
   ZERO: drop drop ;
 
 \ ( -- )   FORTH-79: up to 80 characters, or a line, into TIB; >IN to 0.
@@ -66,15 +73,15 @@ macro (STEP)   (P)+6 a! @ 1 + !                     endmacro
 \ ran out -- is stored after them and is not counted.  >IN is left just past
 \ that delimiter.  With nothing left the count is 0.  The count is a byte,
 \ so a word longer than 255 characters is cut to 255.
-header WORD
-: WORD
+\ The three parts of WORD.  The first is called and returns before anything
+\ else is; the last is jumped to; so WORD's calls of C@ and C! are no deeper
+\ than if it were written in one piece.
+: (WORD-SET) ( c -- )
   255 and (P) a! !
   SPAN a! @  -if A drop 0 A:  (P)+1 a! !
-  >IN a! @   -if B drop 0 B:  (P)+6 a! !
-  SK: (LEFT) -if SKE  drop (CH) if SKS  drop jump SKIPPED      \ past delimiters
-  SKS: drop (STEP) jump SK
-  SKE: drop
-  SKIPPED:
+  >IN a! @   -if B drop 0 B:  (P)+6 a! ! ;
+
+: (WORD-TAKE) ( -- baddr )
   (P)+6 a! @ (P)+7 a! !                      \ where it starts
   SC: (LEFT) -if SCE  drop (CH) if SCE  drop (STEP) jump SC    \ up to a delimiter
   SCE: drop
@@ -94,6 +101,18 @@ header WORD
   RANOUT: drop  0  (P)+2 a! @ WBUF+1 + C!
     (P)+6 a! @  >IN a! !  WBUF ;
 
+header WORD
+: WORD
+  (WORD-SET)
+  SK: (LEFT) -if SKE  drop (CH) if SKS  drop jump (WORD-TAKE)  \ past delimiters
+  SKS: drop (STEP) jump SK
+  SKE: drop  jump (WORD-TAKE)
+
+\ ( c -- baddr )   as WORD, but leading delimiters are not ignored: the text
+\ starts at >IN, and may be empty.  This is what ." needs:  ." "  is an
+\ empty string, where WORD would step over its closing quote.
+: (PARSE)   (WORD-SET)  jump (WORD-TAKE)
+
 \ ---- ENCLOSE ---------------------------------------------------------------
 \ (P)+0 the delimiter, (P)+1 the string's address.
 : (E?) ( i -- i k )     \ k: 0 at the end of the string, 1 at a delimiter, else 2