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.

mac/file.cpp

@@ -160,6 +160,7 @@ strings_t group_filename_tokens(const strings_t& tokens, const std::string& base
         // name exists.  A name that never resolves is kept as given, so the
         // missing-file error downstream reports what the user wrote.
         size_t i = 0;
+        bool reported = false;   // at most one "tried" report per list
         while (i < tokens.size()) {
             if (filename_exists(tokens[i], base_dir)) {
                 result.push_back(tokens[i]);
@@ -173,8 +174,13 @@ strings_t group_filename_tokens(const strings_t& tokens, const std::string& base
                 acc += " " + tokens[j];
                 ++j;
                 if (filename_exists(acc, base_dir)) {
-                    std::cerr << command_name << ": interpreting \""
-                              << acc << "\" as one filename\n";
+                    // A successful regrouping is a DERIVED value -- the
+                    // command completed a name the input left ambiguous -- so
+                    // it is reported at "-v 1" and not at every run.  Silence
+                    // is safe here because a rescue only succeeds when the
+                    // joined name names an existing file: a mistyped name
+                    // fails rather than resolving to something else.
+                    K::log(1, "interpreting", q_(acc), "as one filename");
                     result.push_back(acc);
                     i = j;
                     found = true;
@@ -182,6 +188,27 @@ strings_t group_filename_tokens(const strings_t& tokens, const std::string& base
                 }
             }
             if (!found) {
+                // Nothing resolved.  The groupings that were TRIED are what
+                // the user needs at verbosity 0, because the downstream error
+                // names only the first token and cannot say why the others
+                // were not joined to it.  Recorded on the name so the caller
+                // can report them with the missing-file error.
+                strings_t tried {};
+                std::string acc2 = tokens[i];
+                tried.push_back(q_(acc2));
+                for (size_t k = i + 1; k < tokens.size(); ++k) {
+                    acc2 += " " + tokens[k];
+                    tried.push_back(q_(acc2));
+                }
+                // Once: the first unresolved token's list already shows
+                // every joining from that point on, and one report per
+                // leftover word buries it.
+                if (tried.size() > 1 && !reported) {
+                    std::cerr << command_name << ": no file matches "
+                              << q_(tokens[i]) << "; tried "
+                              << join(tried, ", ") << "\n";
+                    reported = true;
+                }
                 result.push_back(tokens[i]);
                 ++i;
             }