test(osgen): pin perOpErrorTypeName <-> errwrap.OperationWrappers coupling

perOpErrorTypeName's hardcoded switch and errwrap.OperationWrappers'
wrapper-count map are coupled by an unstated invariant: a group has a
per-op aggregator type iff its catalog entry declares 2+ wrappers. Today
both sides match, but nothing checks them, so a future catalog edit can
desync the two without any signal -- the dispatch keeps referencing a
per-op type that's no longer reachable, or worse, emits an empty type
name when a 2+-wrapper group lacks a switch arm.

Add a coupling test that asserts both directions:
  - every group naming a per-op aggregator type has 2+ wrappers in
    OperationWrappers
  - every catalog entry with 2+ wrappers has a non-empty per-op
    aggregator type

Iterates the catalog directly rather than a duplicate list of switch
arms, so a new switch arm or catalog entry is exercised automatically.

Failure messages are actionable: they name the offending group, the
current state, and the remediation (add wrappers, remove switch arm,
or add a hand-written aggregator).

Ref: opensearch-project#844 (review round 3, F7)
Signed-off-by: Sean Chittenden <sean.chittenden@crowdstrike.com>

Author: sean-

cmd/osgen/emit/frag_dispatch_test.go

@@ -306,6 +306,52 @@ func TestDispatchFragment_Imports(t *testing.T) {
 	}
 }
 
+// TestPerOpErrorTypeName_CatalogConsistency pins the implicit coupling
+// between [emit.PerOpErrorTypeName]'s hardcoded switch and
+// [errwrap.OperationWrappers]: every group naming a per-op aggregator
+// type must declare 2+ wrappers in the catalog (otherwise the per-op
+// type is referenced from generated code but the underlying detection
+// paths no longer fire), and every group declaring 2+ wrappers in the
+// catalog must have a per-op aggregator type (otherwise the dispatch
+// emits an empty per-op type name).
+//
+// Without this test, a future catalog edit could desync the two
+// without any signal until generated code stops compiling.
+func TestPerOpErrorTypeName_CatalogConsistency(t *testing.T) {
+	t.Parallel()
+
+	// Forward direction: every group that names a per-op aggregator type
+	// must have 2+ wrappers in the catalog. Iterating the catalog itself
+	// (rather than a duplicate list of switch arms) means a new switch
+	// arm is exercised the moment any group ever appears in either side.
+	for group := range errwrap.OperationWrappers {
+		typeName := emit.PerOpErrorTypeName(group)
+		if typeName == "" {
+			continue
+		}
+		t.Run("type_for_"+group, func(t *testing.T) {
+			t.Parallel()
+			require.GreaterOrEqual(t, len(errwrap.OperationWrappers[group]), 2,
+				"group %q has per-op error type %q but only %d wrapper(s) in OperationWrappers; either add wrappers or remove the switch arm",
+				group, typeName, len(errwrap.OperationWrappers[group]))
+		})
+	}
+
+	// Reverse direction: every catalog entry with 2+ wrappers must name
+	// a per-op aggregator type.
+	for group, wrappers := range errwrap.OperationWrappers {
+		if len(wrappers) < 2 {
+			continue
+		}
+		t.Run("catalog_entry_"+group, func(t *testing.T) {
+			t.Parallel()
+			require.NotEmpty(t, emit.PerOpErrorTypeName(group),
+				"group %q declares %d wrappers %v in OperationWrappers but PerOpErrorTypeName returns empty; add a switch arm and a hand-written %q-style aggregator type",
+				group, len(wrappers), wrappers, group)
+		})
+	}
+}
+
 // ---------------------------------------------------------------------------
 // PartialFailureFragment: per-Resp helper methods + aggregator
 // ---------------------------------------------------------------------------