Store optional requirements beside a plain requires list (hq issue 166, review of #281)

A controller older than optional requirements reads `requires` as names, and Inventory.Catalogue
stops at the first manifest it cannot read: the long form stored inside `requires` would have left
a rollback below this controller composing no machine. Stored, `requires` stays plain and the
optional names sit in `optional-requires`, a key an older controller sets aside, leaving out only
the module carrying it. A refusal of a hard requirement now names a module that wants it hard.

internal/catalogue/optional_requirements.go

@@ -69,18 +69,37 @@ func readRequires(raw json.RawMessage) ([]string, map[string]bool, error) {
 	return names, optional, nil
 }
 
-// writeRequires is `requires` in the form it was read: a bare name for a hard requirement, the long
-// form for an optional one, so a manifest that went through the mesh comes out as it went in.
-func writeRequires(m Manifest) (json.RawMessage, error) {
-	out := make([]any, 0, len(m.Requires))
-	for _, r := range m.Requires {
-		if m.OptionalRequires[r] {
-			out = append(out, requirementForm{Name: r, Optional: true})
-			continue
-		}
-		out = append(out, r)
+// OptionalRequiresKey is where a stored manifest keeps which of its requirements are optional: beside
+// `requires`, which stays a plain list of names (mesh-controller #281's review). A controller older than
+// optional requirements reads `requires` as names; the long form inside it failed that read, and with it
+// the whole catalogue, so a rollback below this controller would have composed no machine. An older
+// controller sets this unknown key aside instead and leaves only the module that carries it out. A
+// manifest may be written either way; it is stored this way.
+const OptionalRequiresKey = "optional-requires"
+
+// readOptionalRequires reads the stored form's list of optional requirements.
+func readOptionalRequires(raw json.RawMessage) (map[string]bool, error) {
+	var names []string
+	if err := json.Unmarshal(raw, &names); err != nil {
+		return nil, fmt.Errorf("%s: a list of the names in `requires` that are optional: %w", OptionalRequiresKey, err)
 	}
-	return json.Marshal(out)
+	out := map[string]bool{}
+	for _, n := range names {
+		out[n] = true
+	}
+	return out, nil
+}
+
+// optionalRequiresList is the stored form's list: the optional requirements, sorted.
+func optionalRequiresList(m Manifest) []string {
+	var out []string
+	for name, optional := range m.OptionalRequires {
+		if optional {
+			out = append(out, name)
+		}
+	}
+	sort.Strings(out)
+	return out
 }
 
 // IsOptional is whether this module requires the name optionally (ADR 0330 §1). A name it contributes
@@ -185,6 +204,12 @@ func OptionalProblems(m Manifest) []string {
 		}
 		required[r] = true
 	}
+	for _, r := range optionalRequiresList(m) {
+		if !required[r] {
+			problems = append(problems, fmt.Sprintf(
+				"%s says %q is optional in %s and does not require it", m.Module, r, OptionalRequiresKey))
+		}
+	}
 	// A contribution is to whoever answers the requirement, so it goes with it: contributing to one
 	// that is optional is allowed, and composed only while it is bound.
 	for _, r := range m.Resources {