fix(audience-session): emit session_end before flipping _initialized in Shutdown

The two-phase refactor broke Shutdown_FiresSessionEnd. Phase 1 flipped
_initialized to false, then Phase 2 called session.Dispose(). Session
fires session_end through ImmutableAudience.Track, which guards on
CanTrack() = _initialized && _consent.CanTrack(). With _initialized
already false, Track dropped the event on the floor.

Added Session.EmitEndAndSeal — an emit-only variant of End() that
fires session_end and resets state but does not drain the heartbeat
timer. Shutdown calls it under _initLock before the flag flip, so
Track's gate still lets session_end through. Heartbeat timer drain
continues to happen in Phase 2 via session.Dispose(); the second
End() inside Dispose no-ops because EmitEndAndSeal already cleared
_sessionId.

Lock hold time is unchanged: EmitEndAndSeal takes Session._lock for
microseconds to compute duration and reset state, then releases
before calling SafeTrack → Track → Enqueue (which takes EventQueue's
_drainLock, also microseconds). Nothing blocking runs under _initLock.

Also drops the column-aligned capture block in Shutdown Phase 1 —
dotnet-format rejects the extra whitespace, so one assignment per line.

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

Author: ImmutableJeffrey

src/Packages/Audience/Runtime/Core/Session.cs

@@ -193,6 +193,31 @@ internal void End()
             });
         }
 
+        // Emits session_end and seals the session without draining the heartbeat
+        // timer. Use when the caller needs to fire session_end inside a short
+        // gating lock (e.g. ImmutableAudience.Shutdown under _initLock while
+        // _initialized is still true) and will drain + dispose the timer after
+        // releasing the lock. Idempotent: a subsequent Dispose() → End() will
+        // find _sessionId null and no-op the re-emission.
+        internal void EmitEndAndSeal()
+        {
+            string sessionId;
+            long duration;
+            lock (_lock)
+            {
+                if (_disposed || _sessionId == null) return;
+                sessionId = _sessionId!;
+                duration = ComputeEngagedSecondsLocked();
+                ResetSessionStateLocked();
+            }
+
+            SafeTrack("session_end", new Dictionary<string, object>
+            {
+                ["sessionId"] = sessionId,
+                ["durationSec"] = duration
+            });
+        }
+
         public void Dispose()
         {
             lock (_lock)

src/Packages/Audience/Runtime/ImmutableAudience.cs

@@ -547,16 +547,29 @@ public static void Shutdown()
             {
                 if (!_initialized) return;
 
-                // Flip the gate first. Init / SetConsent / Reset acquiring after
+                // Emit session_end inside the lock while _initialized is still
+                // true so Track's CanTrack gate lets it through. Heartbeat timer
+                // drain is deferred to Phase 2; the second emission from
+                // session.Dispose → End() no-ops because EmitEndAndSeal reset
+                // _sessionId.
+                _session?.EmitEndAndSeal();
+
+                // Flip the gate. Init / SetConsent / Reset acquiring after
                 // this see _initialized == false and return cleanly.
                 _initialized = false;
 
-                session       = _session;                    _session = null;
-                timer         = _sendTimer;                  _sendTimer = null;
-                queue         = _queue;                      _queue = null;
-                transport     = _transport;                  _transport = null;
-                controlClient = _controlClient;              _controlClient = null;
-                cts           = _shutdownCancellationSource; _shutdownCancellationSource = null;
+                session = _session;
+                _session = null;
+                timer = _sendTimer;
+                _sendTimer = null;
+                queue = _queue;
+                _queue = null;
+                transport = _transport;
+                _transport = null;
+                controlClient = _controlClient;
+                _controlClient = null;
+                cts = _shutdownCancellationSource;
+                _shutdownCancellationSource = null;
 
                 timeoutMs = _config?.ShutdownFlushTimeoutMs ?? 2_000;