Option sets: a .o target for shared parameters

A named group of optional parameters, declared once and used by several
klammers, so a writer learns one vocabulary instead of a spelling per
klammer.  The "o" target is a pseudo-target beside "k": "k" declares a
klammer's interface and documents it, "o" declares an option interface and
documents it, and neither produces output for any target.

    @@caption_args.o :caption :number.bool true :caption_side.side
    : Arguments that define a caption for a block element @@

    @@code.k :filename @hpos_args :hpos left @ @caption_args :caption_side top @
    | text.literal : A source file displayed verbatim @@

A set is used only in the parameter list of a ".k" declaration -- the one
place a klammer's interface is declared once for all of its targets -- and
is resolved as that list is read.  Names and types come from the set; a
default may be overridden where it is used.  A klammer application in a
parameter list is now a definition-time error.

The SKS gains the sets caption_args and hpos_args (:hpos and :offset), and
@table, @image, @image_grid, @reference and @show gain .k declarations.  A
distance is no longer written as a position: :hpos 4em is rejected, and the
same layout is :hpos left :offset 4em.  Code listings are numbered by
default, like tables and figures.

New engine sources mac/option_set{,_registry}.{h,cpp}; tst/ ships two more
suites, option_set_test.sh and signature_test.sh (twelve in all).

 (from dev 34e536cb0329)

mac/option_set.cpp

@@ -0,0 +1,64 @@
+#include <sstream>
+
+#include "option_set.h"
+#include "argtype_registry.h"
+#include "util.h"
+
+Option_set::Option_set(
+    const std::string& name, const std::string& desc,
+    const Parameter_set& parameters, const katom_lists& members, const Locator& loc)
+    : m_name(name)
+    , m_desc(desc)
+    , m_parameters(parameters)
+    , m_members(members)
+    , m_loc(loc)
+{}
+
+const Parameter* Option_set::find(const std::string& name) const
+{
+    for (const Parameter& p : m_parameters.m_optional) {
+        if (p.m_name == name) {
+            return &p;
+        }
+    }
+    return nullptr;
+}
+
+std::string Option_set::member_names() const
+{
+    std::vector<std::string> names {};
+    for (const Parameter& p : m_parameters.m_optional) {
+        names.push_back(":" + p.m_name);
+    }
+    return join(names, " ");
+}
+
+// One member per line: the name, its type, and its default -- the same three
+// things a klammer's signature shows, since that is what the using klammer
+// ends up declaring.
+std::string Option_set::describe(int margin) const
+{
+    std::string tab(margin, ' ');
+    std::stringstream ss {};
+    ss << tab << "@@" << m_name << ".o\n";
+    for (const Parameter& p : m_parameters.m_optional) {
+        std::string line = ":" + p.m_name;
+        if (p.m_argtype.m_name != default_argtype) {
+            line += "." + p.m_argtype.m_name;
+        }
+        if (!p.m_default.empty()) {
+            line += " " + p.m_default;
+            if (p.m_default_from_type) {
+                line += "  (from the " + p.m_argtype.m_name + " argument type)";
+            }
+        }
+        ss << tab << "  " << line << "\n";
+    }
+    if (!m_desc.empty()) {
+        ss << justify(m_desc, 80, margin + 2) << "\n";
+    }
+    if (!m_users.empty()) {
+        ss << tab << "  Used by: " << join(m_users, ", ") << "\n";
+    }
+    return ss.str();
+}