test(audience-session): regression test proving _initLock is released before Phase 2

Locks a Shutdown inside its Phase 2 final flush via a BlockingHandler
that never returns from SendAsync, then calls Reset on the main
thread with a stopwatch. Pre-refactor, Reset would wait on _initLock
for the full ShutdownFlushTimeoutMs (up to 10s in this test's setup).
Post-refactor, Reset acquires the lock immediately, sees
!_initialized, and returns in microseconds.

Asserts Reset completes in under 500ms — generous margin to avoid CI
flakes while still catching a regression that re-introduces a
seconds-scale hold.

Addresses the reviewer's concern from PR #699 and guards against
future changes that move blocking work back inside the lock.

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

Author: ImmutableJeffrey

src/Packages/Audience/Tests/Runtime/ImmutableAudienceTests.cs

@@ -951,6 +951,44 @@ public void Track_AfterShutdown_IsIgnored()
             Assert.DoesNotThrow(() => ImmutableAudience.Track("should_not_crash"));
         }
 
+        [Test]
+        public void Shutdown_ReleasesInitLock_BeforeBlockingTeardown()
+        {
+            // Hanging handler: the final flush inside Shutdown's Phase 2 will
+            // block in transport.SendBatchAsync().Wait(timeoutMs). Pre-refactor,
+            // _initLock was held across that wait — SetConsent / Reset on another
+            // thread would be stranded for the full ShutdownFlushTimeoutMs.
+            var handler = new BlockingHandler();
+            var config = MakeConfig();
+            config.HttpHandler = handler;
+            config.ShutdownFlushTimeoutMs = 10_000;
+
+            ImmutableAudience.Init(config);
+            ImmutableAudience.Track("ensure_nonempty_queue");
+            ImmutableAudience.FlushQueueToDiskForTesting();
+
+            // Phase 1 flips _initialized and releases the lock; Phase 2 enters
+            // the hanging final flush.
+            var shutdown = Task.Run(() => ImmutableAudience.Shutdown());
+
+            Assert.IsTrue(handler.EnteredSendAsync.Wait(TimeSpan.FromSeconds(5)),
+                "Shutdown should reach the hanging final flush inside Phase 2");
+
+            // Reset unconditionally acquires _initLock. If Phase 2 held the lock
+            // this would block for ~10s; post-refactor the lock is free, Reset
+            // sees !_initialized and returns in microseconds.
+            var sw = System.Diagnostics.Stopwatch.StartNew();
+            ImmutableAudience.Reset();
+            sw.Stop();
+
+            Assert.Less(sw.ElapsedMilliseconds, 500,
+                $"Reset must not block on Shutdown's Phase 2; took {sw.ElapsedMilliseconds}ms");
+
+            handler.Release.Set();
+            Assert.IsTrue(shutdown.Wait(TimeSpan.FromSeconds(15)),
+                "Shutdown should finish after handler release");
+        }
+
         // -----------------------------------------------------------------
         // Full -> Anonymous consent downgrade
         // -----------------------------------------------------------------