feat(stream): retry a dropped push instead of ending the session (TASK 32·1)

A dead encoder used to run the whole stop path, so a one-second blip ended the broadcast. Now a dropped
push is relaunched against the same ingest while the broadcast is still alive.

- `Services/StreamRetryPolicy.cs` — immediate, +1 s, +2 s, +3 s. Minimum waits on purpose (creator
  ruling): YouTube's grace is short, so every second not pushing is grace spent.
- `Services/StreamRecovery.cs` — the loop, with the audio pipe recreated before every attempt (its
  server is single-instance and unusable after the old client dies, so a naive relaunch fails on a
  missing input). After a push comes up it asks the API whether the broadcast survived: "complete"
  ends recovery as `BroadcastComplete` instead of showing a live sign over a dead stream; an API
  hiccup counts as recovered rather than ending a healthy session.
- `FramePump.EncoderFailed` — a dead push is recoverable; a compositor fault still goes through
  `Failed` and ends the session, because retrying it would loop.
- `MainViewModel.Recovery.cs` — wires the steps, reports each episode into the left panel alert stack
  (one row per episode, updated in place, log range painted), and cancels on Stop.
- Alert stack polish: a rule and a gap now separate the stack from the scene layers (they read as one
  list before), and the licence indicator uses the creator's wording — `STEAM ID NOT PRESENT` /
  `Steam ID Limit: 30fps` / `Click for More Info`, becoming `STEAM ID PRESENT` / `60fps` with a close
  control once owned.

Tests: `StreamRecoveryTests` (schedule, recover on attempt 2 with the pipe restarted each time,
complete-broadcast honesty, unknown liveness, give-up, cancel, audio-restart fault),
`FramePumpTests` now pin that process death raises `EncoderFailed` and not `Failed`.
FAST gate: 538 passed (one documented pre-existing audio failure), 0 warnings.

Services/YouTubeStreamService.cs

@@ -182,6 +182,25 @@ public class YouTubeStreamService
     /// "public"), read from YouTube rather than trusted from local state — the creator can
     /// change visibility mid-stream from the broadcast form. Null when signed out or the
     /// read fails (the caller then does nothing destructive).</summary>
+    /// <summary>TASK 32·1: the broadcast's lifecycle status (<c>created</c>/<c>ready</c>/<c>testing</c>/
+    /// <c>live</c>/<c>complete</c>), or null when it cannot be read. Used after a reconnect: a push can
+    /// succeed at the socket level while YouTube has already ended the broadcast.</summary>
+    public async Task<string?> GetBroadcastStatusAsync(string broadcastId)
+    {
+        if (!await EnsureToken()) return null;
+
+        _http.DefaultRequestHeaders.Authorization = new("Bearer", _auth.CurrentChannel!.AccessToken);
+        var response = await _http.GetAsync(
+            $"{ApiBase}/liveBroadcasts?part=status&id={Uri.EscapeDataString(broadcastId)}");
+        if (!response.IsSuccessStatusCode) return null;
+
+        var json = JsonSerializer.Deserialize<JsonElement>(await response.Content.ReadAsStringAsync());
+        if (!json.TryGetProperty("items", out var items) || items.GetArrayLength() == 0) return null;
+        if (!items[0].TryGetProperty("status", out var status)) return null;
+        if (!status.TryGetProperty("lifeCycleStatus", out var lifeCycle)) return null;
+        return lifeCycle.ValueKind == JsonValueKind.String ? lifeCycle.GetString() : null;
+    }
+
     public async Task<string?> GetBroadcastPrivacyAsync(string broadcastId)
     {
         if (!await EnsureToken()) return null;