feat(settings): editing during a session is the creator's call (default: allowed)

Creator ruling 2026-11-12: "we don't care if a creator wants to edit their scene: move stuff around,
shrink/grow a webcam view, etc. Why not?" Correct — the app was only ever *forcing* EDIT off at
go-live, never enforcing it, so the gun-safety was a habit rather than a rule.

App.LockEditWhileLive ships off: a show no longer takes EDIT away. Turning it on restores the old
behaviour exactly — go-live flips EDIT off and stop flips it back, and only because the lock took it,
so a creator who had already turned EDIT off does not get it handed back on stop.

MainViewModel.ApplyEditLockForSession holds the rule so it is testable without starting a broadcast;
EditWhileLiveTests covers both settings, the round trip, and the "don't hand it back" case. Settings →
Editing carries the checkbox.

This is the first slice of TASK 68 (editing while live).

678 pass, 0 warnings. Scope justification: Assets/starting-background.jpg is outside this unit — the
creator's replacement art, still awaiting their visual check.

ViewModels/MainViewModel.Settings.cs

@@ -15,6 +15,8 @@ public partial class MainViewModel
     private bool _settingsDrawerOpen;
     private NotificationPosition _toastPosition = NotificationPosition.BottomRight;
     private bool _stickyAlertsUntilDismissed;
+    private bool _lockEditWhileLive;
+    private bool _editingForcedOff;
 
     public bool StickyAlertsUntilDismissed
     {
@@ -26,6 +28,43 @@ public partial class MainViewModel
         }
     }
 
+    /// <summary>Lock editing for the duration of a session. Off = edit while live (creator ruling
+    /// 2026-11-12); on = go-live flips EDIT off and stop flips it back, as it always did.</summary>
+    public bool LockEditWhileLive
+    {
+        get => _lockEditWhileLive;
+        set
+        {
+            if (!SetProperty(ref _lockEditWhileLive, value)) return;
+            _layoutStore.SaveLockEditWhileLive(value);
+        }
+    }
+
+    /// <summary>
+    /// Applies the edit lock when a session starts or stops. Split out so the rule is testable without
+    /// starting a real broadcast.
+    /// </summary>
+    internal void ApplyEditLockForSession(bool starting)
+    {
+        if (!LockEditWhileLive)
+        {
+            // The creator may edit during the show; nothing is forced either way.
+            _editingForcedOff = false;
+            return;
+        }
+
+        if (starting)
+        {
+            _editingForcedOff = true;
+            EditingActive = false;
+        }
+        else if (_editingForcedOff)
+        {
+            _editingForcedOff = false;
+            EditingActive = true;
+        }
+    }
+
     public NotificationPosition ToastPosition
     {
         get => _toastPosition;