feat(audience): add Json.Serialize(dict, indent) pretty-print overload

Second overload indenting nested containers by `indent` spaces per
level. Round-trips through Deserialize identically; indent ≤ 0
routes to the existing compact Serialize, so every wire-payload
caller is unaffected.

Internal scaffolding:
- WriteObject / WriteArray / WriteValue thread indent + depth so the
  overload can emit newlines and leading spaces at the correct
  nesting level.
- AppendNewline helper centralises the "\n + (indent * depth) spaces"
  pattern.
- pretty-path writes ":" with a trailing space; empty containers stay
  on a single line ({} / []), matching the compact form for collapsed
  nodes.

No behaviour change on the compact overload for any existing caller;
the indent threading is inert when indent == 0 (pretty=false).

Motivated by the sample-app landing next — its Init tab renders the
effective AudienceConfig as an echo view, and the Events/Identity
tabs show constructed property dicts, all via Json.Serialize(…, 2).

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

Author: ImmutableJeffrey

src/Packages/Audience/Runtime/Utility/Json.cs

@@ -10,11 +10,23 @@ internal static class Json
         internal static string Serialize(Dictionary<string, object> data)
         {
             var sb = new StringBuilder();
-            WriteObject(sb, data);
+            WriteObject(sb, data, indent: 0, depth: 0);
             return sb.ToString();
         }
 
-        private static void WriteValue(StringBuilder sb, object value)
+        // Pretty-prints `data` with `indent` spaces per nesting level.
+        // Round-trips through Deserialize identically. Indent ≤ 0 returns
+        // the compact form. Use for human-readable output; wire payloads
+        // use the compact overload.
+        internal static string Serialize(Dictionary<string, object> data, int indent)
+        {
+            if (indent <= 0) return Serialize(data);
+            var sb = new StringBuilder();
+            WriteObject(sb, data, indent, depth: 0);
+            return sb.ToString();
+        }
+
+        private static void WriteValue(StringBuilder sb, object value, int indent, int depth)
         {
             if (value == null)
             {
@@ -56,46 +68,60 @@ private static void WriteValue(StringBuilder sb, object value)
             }
             else if (value is Dictionary<string, object> dict)
             {
-                WriteObject(sb, dict);
+                WriteObject(sb, dict, indent, depth);
             }
             else if (value is IList list)
             {
-                WriteArray(sb, list);
+                WriteArray(sb, list, indent, depth);
             }
             else
             {
                 WriteString(sb, value.ToString());
             }
         }
 
-        private static void WriteObject(StringBuilder sb, Dictionary<string, object> dict)
+        private static void WriteObject(StringBuilder sb, Dictionary<string, object> dict, int indent, int depth)
         {
             sb.Append('{');
+            if (dict.Count == 0) { sb.Append('}'); return; }
+
+            var pretty = indent > 0;
             var first = true;
             foreach (var kvp in dict)
             {
-                if (!first)
-                    sb.Append(',');
+                if (!first) sb.Append(',');
                 first = false;
+                if (pretty) AppendNewline(sb, indent, depth + 1);
                 WriteString(sb, kvp.Key);
-                sb.Append(':');
-                WriteValue(sb, kvp.Value);
+                sb.Append(pretty ? ": " : ":");
+                WriteValue(sb, kvp.Value, indent, depth + 1);
             }
+            if (pretty) AppendNewline(sb, indent, depth);
             sb.Append('}');
         }
 
-        private static void WriteArray(StringBuilder sb, IList list)
+        private static void WriteArray(StringBuilder sb, IList list, int indent, int depth)
         {
             sb.Append('[');
+            if (list.Count == 0) { sb.Append(']'); return; }
+
+            var pretty = indent > 0;
             for (var i = 0; i < list.Count; i++)
             {
-                if (i > 0)
-                    sb.Append(',');
-                WriteValue(sb, list[i]);
+                if (i > 0) sb.Append(',');
+                if (pretty) AppendNewline(sb, indent, depth + 1);
+                WriteValue(sb, list[i], indent, depth + 1);
             }
+            if (pretty) AppendNewline(sb, indent, depth);
             sb.Append(']');
         }
 
+        private static void AppendNewline(StringBuilder sb, int indent, int depth)
+        {
+            sb.Append('\n');
+            sb.Append(' ', indent * depth);
+        }
+
         private static void WriteString(StringBuilder sb, string s)
         {
             sb.Append('"');