schemagen: reject self-referential array $ref cycles instead of crashing

Cyclic array definitions (directly or through a chain of array $defs)
created a self-referential TArr, which then caused infinite recursion in
base_cpp, storage_cpp, and _walk_arrays.

Object-only cycles are already broken with std::unique_ptr, but
array-only cycles have no object edge for break_cycles to cut.

Detect them after building an array's items by following TArr.elem links
and raise a clear GenError so generation fails gracefully rather than
overflowing the Python stack.

Closes #33

contrib/schemagen/weaseljson_schemagen.py

@@ -235,6 +235,24 @@ class Builder:
         """Names generated internally that must not collide with user types."""
         return name in ("Root", "RootScalar")
 
+    @staticmethod
+    def _array_reaches(target, ty):
+        """Return True if `target` can be reached from `ty` by following
+        TArr element types. This detects self-referential array cycles that
+        cannot be expressed as C++ structs."""
+        seen = set()
+        stack = [ty]
+        while stack:
+            cur = stack.pop()
+            if cur is target:
+                return True
+            if id(cur) in seen:
+                continue
+            seen.add(id(cur))
+            if isinstance(cur, TArr):
+                stack.append(cur.elem)
+        return False
+
     def ref_name(self, ref):
         if not ref.startswith("#/"):
             raise GenError(f"only local $ref supported, got: {ref}")
@@ -322,6 +340,12 @@ class Builder:
             )
             t.elem = elem
             t.elem_nullable = elem_nullable
+            # Self-referential array cycles (directly or through a chain of
+            # array definitions) cannot be represented as a C++ value type.
+            if self._array_reaches(t, elem):
+                raise GenError(
+                    "recursive array type is not supported: " f"{defname or hint!r}"
+                )
             return result
 
         scalar = {