An output policy for the three commands, and @cond as a true special form

A snapshot of the development tree.  The substantial changes since the last one:

COMMAND OUTPUT POLICY.  The three commands display text in exactly three cases,
and each owns a stream: LOGGING under "-v" greater than 0 and an ERROR before
termination go to STDERR; OUTPUT THE USER ASKED FOR goes to STDOUT.  For ktext
that output is a document, so "ktext doc.kt -d | ..." is now safe -- logging
used to share the stream and land inside the document.  A bare command prints
its usage and succeeds rather than failing.  Colour is emitted only to a
terminal, per stream, and NO_COLOR is honoured.

"-v 1" reports every decision whose outcome you could not have read off your own
input: the klammerset that was loaded and from which file, a font's directory, a
":files" name's file, how "-o" was expanded.  Higher levels are the trace.

The commands no longer warn and continue: an anomaly is an error, described with
its location.  Two exceptions remain, each for a stated reason -- a condition
that is expected and temporary by design, and a judgment that is a heuristic
rather than exact.

@cond IS NOW A TRUE SPECIAL FORM, resolved at APPLICATION time rather than when
the file is read.  Two consequences for a writer:

  * a state variable reaches the predicate.  "@@@state Flag :value true @@@
    @cond *Flag* | T | F @" renders "T"; it used to see the literal "*Flag*" and
    silently take the false branch.  The document now behaves like a klammer
    body, whose arguments are bound before its conditionals are decided.
  * nothing in a discarded branch happens -- it is not read, not evaluated, not
    expanded.  An @eval in the branch not taken used to run anyway.

Its predicate relation is total and strict: true, True, 1; false, False, 0, and
empty; anything else is an error at the @cond rather than silently false.

@eval REACHING OUTSIDE.  ":shell" and ":haskell" now keep the command's standard
error out of the document (it appears under "-v 1") and treat a nonzero exit as
an error naming what the command reported.  A command that exits nonzero on
purpose -- "grep" finding no match -- says so with "|| true".

KLAMMER SETS.  Several combine: "--klammersets a b c" loads all three in the
order given, sharing one namespace, with the definition modes deciding
collisions.  "none" means none and may not be combined with other symbols.  A
klammerset with symbol X is declared in a file X/X.k, which is what lets two
sets require the same third set without loading it twice.

TESTS.  Four new suites: the kdiag command's interface, the @eval primitive's
contract with the outside world, and verbosity at both tiers.  Three suites
that could not run on macOS at all now do.

Assembled from dev commit 6c8ee6c22fca.

tst/command_option_test.sh

@@ -113,6 +113,76 @@ else
     echo "SKIP  13/14. two positionals (argv_test not built; run make -C tst)"
 fi
 
+echo
+echo "-- the output policy: three categories, two streams --"
+# The three commands display text in exactly three cases:
+#   1. logging under "-v" > 0        -> STDERR
+#   2. an error before termination   -> STDERR
+#   3. output the user asked for     -> STDOUT
+# For ktext, category 3 is a DOCUMENT that may be piped, so nothing else may
+# share the stream.  It did: K::log and msg() both wrote to stdout, so
+# "ktext -d -v 1 > doc.txt" put the whole argument dump inside the document.
+OUTF=$(mktemp /tmp/kout.XXXXXX); ERRF=$(mktemp /tmp/kerr.XXXXXX)
+trap 'rm -f "$OUTF" "$ERRF"' EXIT
+
+ktext --klammersets none -s 'hello' -d -v 1 > "$OUTF" 2> "$ERRF"
+if [ "$(cat "$OUTF")" = "hello" ]; then
+    echo "${green}PASS${reset} 15. stdout under -d -v 1 is the document, nothing else"
+    PASS=$((PASS+1))
+else
+    echo "${red}FAIL${reset} 15. stdout carried more than the document"
+    echo "       got: $(head -3 "$OUTF")"; FAIL=$((FAIL+1))
+fi
+if [ -s "$ERRF" ]; then
+    echo "${green}PASS${reset} 16. ... and the -v 1 logging went to stderr"; PASS=$((PASS+1))
+else
+    echo "${red}FAIL${reset} 16. -v 1 produced no stderr"; FAIL=$((FAIL+1))
+fi
+# -v 0 adds nothing anywhere: silence is the default, on both streams.
+ktext --klammersets none -s 'hello' -d > "$OUTF" 2> "$ERRF"
+if [ "$(cat "$OUTF")" = "hello" ] && [ ! -s "$ERRF" ]; then
+    echo "${green}PASS${reset} 17. -v 0 is silent on both streams"; PASS=$((PASS+1))
+else
+    echo "${red}FAIL${reset} 17. -v 0 was not silent (stderr: $(head -2 "$ERRF"))"
+    FAIL=$((FAIL+1))
+fi
+# An error is category 2: stderr, and nothing on stdout to confuse a pipe.
+ktext --klammersets none -s '@nosuch x @' -d > "$OUTF" 2> "$ERRF"
+if [ ! -s "$OUTF" ] && [ -s "$ERRF" ]; then
+    echo "${green}PASS${reset} 18. an error goes to stderr, leaving stdout empty"; PASS=$((PASS+1))
+else
+    echo "${red}FAIL${reset} 18. error stream discipline (stdout: $(head -2 "$OUTF"))"
+    FAIL=$((FAIL+1))
+fi
+# Colour is emitted only to a terminal, so a redirected stream never carries
+# escape sequences -- into a document, a pipe, or a captured log.
+for pair in "ktext:--klammersets none -s hello -d" "kdesc:-k table" "kdiag:@i-x"; do
+    cmd=${pair%%:*}; rest=${pair#*:}
+    # shellcheck disable=SC2086
+    $cmd $rest > "$OUTF" 2> "$ERRF"
+    if ! grep -q $'\033' "$OUTF" && ! grep -q $'\033' "$ERRF"; then
+        echo "${green}PASS${reset} 19. no escape sequences from $cmd when redirected"
+        PASS=$((PASS+1))
+    else
+        echo "${red}FAIL${reset} 19. $cmd emitted colour to a non-terminal"; FAIL=$((FAIL+1))
+    fi
+done
+
+echo
+echo "-- a bare command is a request, not a failure --"
+# Usage is the result being asked for: stdout, exit 0.  It exited 1, so
+# "kdesc && echo ok" reported failure for a successful help request.
+for cmd in ktext kdesc kdiag; do
+    $cmd > "$OUTF" 2> "$ERRF"; status=$?
+    if [ $status -eq 0 ] && [ -s "$OUTF" ] && ! [ -s "$ERRF" ]; then
+        echo "${green}PASS${reset} 20. $cmd with no arguments: usage on stdout, exit 0"
+        PASS=$((PASS+1))
+    else
+        echo "${red}FAIL${reset} 20. $cmd bare: exit $status, stdout $(wc -l < "$OUTF") lines, stderr $(wc -l < "$ERRF") lines"
+        FAIL=$((FAIL+1))
+    fi
+done
+
 echo
 echo "===================="
 echo "Results: ${PASS} passed, ${FAIL} failed"