Target coverage: a klammer states the targets it serves

kdesc gains --coverage, which reports for every klammer the set of targets it
can render to, and — the point of it — which klammers' coverage cannot be
derived and must therefore be declared.  Three rules: coverage is DERIVED
where the definitions determine it (a general body of klammer calls covers
the intersection of what those klammers cover, by a greatest fixpoint after
loading), DECLARED where the engine cannot interpret what decides it (an
@eval body, whose targets are undecidable), and UNKNOWN where nothing is
written — which never means "deliberately unavailable".

Two new spellings in a definition's name.  A comma-separated target list,
"@@table.html,tex :: ...", gives one body several targets; it is surface
syntax, expanded at registration, and each member goes through the
redefinition rules on its own.  And "@@date.* :: ..." writes the general
target out, asserting that the klammer works for EVERY target including ones
not yet defined — a stronger claim than a list of the targets defined today,
and the one target declaration that could be mechanically falsified.

The Standard Klammer Set was swept accordingly: it now has no general
definitions at all, every klammer names the targets it serves, six use ".*",
and tex and pdf are at zero undecided.

kdesc's flags are reorganised on two rules: a flag reached for often gets a
single letter (-k klammers, -t targets, -c characters, -i input), a more
specialised topic a multi-letter name (--argtypes, --katoms, --rewrite,
--optionsets, --coverage, --klammerset, --font); and -v says how much to show
about PROCESSING, never what the RESULT contains — so the katom regex column
is "--katoms full" and the coverage detail "--coverage all".  NOTE: "-k" now
lists klammers (optionally filtered by a name/description search); the katom
table moved to "--katoms".

Fixes carried along: an option written with no value crashed the command with
SIGSEGV instead of reporting the mistake; two required positional arguments
never parsed; kdesc and kdiag printed an error and exited 0; and definition
diagnostics counted registrations rather than what was written, so one line
could be reported as two definitions and then printed twice.

Four new test suites: target_list, coverage, command_option, kdesc.

(from dev 46f54080bd9a)

mac/klammer.h

@@ -18,7 +18,9 @@ public:
 
     using variable_map_t = std::map<std::string, std::vector<int>>;
     using target_variable_map_t = std::map<std::string, variable_map_t>;
-    static std::regex name_re; // = std::regex(R"((\w+)(?:\.(\w+))?)");
+    // <name>[.<target>[,<target>...]] -- the target part is a comma-separated
+    // list so that one body can serve several targets (see parse_name).
+    static std::regex name_re; // = std::regex(R"((\w+)(?:\.(\w+(?:,\w+)*))?)");
 
     struct components {
         std::string target;
@@ -93,11 +95,26 @@ public:
     // target -> true if this target's body came from a general ("*") definition
     // (writer content, subject to target escaping) vs a target-specific one.
     std::map<std::string, bool> m_body_generic {};
+    // True when a definition wrote the general target out as ".*" instead of
+    // omitting the suffix.  Identical to the engine; to a reader it is the
+    // difference between "I did not say" and "I say: every target, whatever
+    // they turn out to be".  Only the second is a claim the coverage report
+    // can repeat.
+    bool m_general_declared { false };
 };
 
 std::string klammer_name_from_katom(const std::string& s, const Locator& loc);
 
-std::tuple<std::string,std::string>
+// Split "@@<name>[.<target>[,<target>...]]" into the klammer name and the
+// targets the definition is for.  Always at least one name: an absent suffix
+// is the general target.  A comma list is surface syntax only -- the caller
+// registers one definition per target, so nothing downstream of registration
+// knows a list was written.
+// The third result is true when the general target was written out as "*"
+// rather than left off.  Both mean the same to the engine; they mean
+// different things to a reader and to the coverage analysis -- see
+// Klammer::m_general_declared.
+std::tuple<std::string,strings_t,bool>
 parse_name(const Target_registry& targets, const Katom& name_katom);
 
 // Split a definition's katoms into its definition separator, parameters,