test(audience): pin Json.Serialize depth guard and cycle detection

Both guards exist because their absence yields StackOverflowException,
which the .NET runtime does not catch — the process terminates. Neither
guard had a test. Three new tests:

- nesting one level past MaxDepth throws FormatException with "nesting
  exceeds" message. Sabotage: disabling GuardDepth fails the test.
- self-referential dict throws FormatException with "cycle" message.
  Sabotage: disabling the visited.Add(container) check makes the test
  recurse into the depth guard and the assertion on "cycle" text fails.
- shared-child diamond (same dict in two sibling keys) is not treated as
  a cycle. Sabotage: removing the post-recursion visited.Remove makes
  the second sibling throw "cycle".

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: ImmutableJeffrey

src/Packages/Audience/Tests/Runtime/Utility/JsonTests.cs

@@ -1,3 +1,4 @@
+using System;
 using System.Collections.Generic;
 using NUnit.Framework;
 
@@ -203,5 +204,48 @@ public void Serialize_RealisticEventPayload_ProducesCorrectJson()
             StringAssert.Contains("\"perfect\":true", result);
             StringAssert.Contains("\"tags\":[\"fast\",\"clean\"]", result);
         }
+
+        [Test]
+        public void Serialize_NestingExceedsMaxDepth_ThrowsFormatException()
+        {
+            var root = new Dictionary<string, object>();
+            var current = root;
+            for (var i = 0; i < Json.MaxDepth; i++)
+            {
+                var next = new Dictionary<string, object>();
+                current["next"] = next;
+                current = next;
+            }
+
+            var ex = Assert.Throws<FormatException>(() => Json.Serialize(root));
+            StringAssert.Contains("nesting exceeds", ex.Message);
+        }
+
+        [Test]
+        public void Serialize_SelfReferentialDict_ThrowsFormatException()
+        {
+            var root = new Dictionary<string, object>();
+            root["self"] = root;
+
+            var ex = Assert.Throws<FormatException>(() => Json.Serialize(root));
+            StringAssert.Contains("cycle", ex.Message);
+        }
+
+        [Test]
+        public void Serialize_SharedChildInSiblingKeys_IsNotTreatedAsCycle()
+        {
+            // Diamond: visited set tracks the current recursion stack, not all objects ever seen.
+            var shared = new Dictionary<string, object> { ["k"] = "v" };
+            var root = new Dictionary<string, object>
+            {
+                ["a"] = shared,
+                ["b"] = shared,
+            };
+
+            var result = Json.Serialize(root);
+
+            StringAssert.Contains("\"a\":{\"k\":\"v\"}", result);
+            StringAssert.Contains("\"b\":{\"k\":\"v\"}", result);
+        }
     }
 }