feat(ui): Gameplay tab — 14 retail CharacterOption-derived toggles

Phase L.0 (cont.) — third tab on the Settings shell, in the Easy-wins
build order. Subset of retail's CharacterOption + CharacterOptions2
bitfield flags ported as bools (see acclient.h:3404+ enum). Local-
only this phase per the brainstorm — server sync deferred to a
later phase that will marshal the draft into the retail
CharacterOption packet.

GameplaySettings record exposes 14 named flags grouped by usage:

 · Combat: AutoTarget, AutoRepeatAttack, ToggleRun, AdvancedCombatUI,
   VividTargetingIndicator
 · Display: ShowTooltips, SideBySideVitals, CoordinatesOnRadar,
   SpellDuration, ShowHelm, ShowCloak
 · Interface: AllowGive, LockUI, UseMouseTurning

Retail names + bit values are documented in field-level comments so
the future server-sync phase has a 1:1 mapping. Defaults are
typical-user starting points (NOT bit-exact to retail's
0x50C4A54A / 0x948700 masks); class-level remarks call out that
defaults will be re-anchored to retail values once the wire-format
is the load-bearing source.

SettingsStore grows LoadGameplay / SaveGameplay using the existing
SaveSection generic helper (added in the audio commit). All three
non-keybind sections (display, audio, gameplay) now coexist in
settings.json with non-destructive cross-section saves — verified
by a new "all three sections coexist" round-trip test.

SettingsVM grows the parallel gameplay state machine
(gameplayPersisted / gameplayDraft / SetGameplay / onSaveGameplay).
HasUnsavedChanges, Save, Cancel, ResetAllToDefaults all cover
gameplay too. Constructor signature adds two more params; existing
call sites (App startup + tests) updated.

SettingsPanel.RenderGameplayTab replaces the L.0-shell placeholder —
14 Checkbox calls grouped under three Text+Separator headers, plus
a footer note explaining the local-only-this-phase scope. The
"Coming soon" placeholder test was retargeted from "Gameplay" to
"Chat" since Gameplay is no longer a placeholder.

GameWindow construction site loads gameplay on startup + writes via
the SettingsStore on Save. Server-sync packet wiring is left as a
TODO comment in the onSaveGameplay callback (next phase, after the
protocol round-trip is in place).

14 new tests:
 · GameplaySettings record (3) — defaults pinned, value equality,
   with-expressions
 · SettingsStore gameplay (4) — missing-file → defaults, round-trip,
   partial-file fallback, all-three-sections coexist
 · SettingsVM gameplay (5) — initial draft, SetGameplay marks dirty,
   Save invokes callback, Cancel reverts, ResetAllToDefaults covers
 · SettingsPanel gameplay tab (2) — 8 spot-checked Checkboxes render
   only when active

dotnet build green (0 warnings); dotnet test 1,276 / 1,276 green
(243 Core.Net + 360 UI.Abstractions + 673 Core).

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

src/AcDream.UI.Abstractions/Panels/Settings/SettingsPanel.cs

@@ -93,7 +93,7 @@ public sealed class SettingsPanel : IPanel
             }
             if (renderer.BeginTabItem("Gameplay"))
             {
-                RenderPlaceholder(renderer, "Gameplay");
+                RenderGameplayTab(renderer);
                 renderer.EndTabItem();
             }
             if (renderer.BeginTabItem("Chat"))
@@ -272,6 +272,90 @@ public sealed class SettingsPanel : IPanel
             + "values to settings.json; Cancel reverts to the saved values.");
     }
 
+    /// <summary>
+    /// Render the Gameplay tab — ~14 toggles ported from retail's
+    /// CharacterOption + CharacterOptions2 bitfields. Local-only this
+    /// phase (no server sync). Grouped into Combat / Display / Interface
+    /// for first-run discoverability.
+    /// </summary>
+    private void RenderGameplayTab(IPanelRenderer renderer)
+    {
+        var g = _vm.GameplayDraft;
+
+        renderer.Text("Combat");
+        renderer.Separator();
+
+        bool autoTarget = g.AutoTarget;
+        if (renderer.Checkbox("Auto-target on attack", ref autoTarget))
+            _vm.SetGameplay(g with { AutoTarget = autoTarget });
+
+        bool autoRepeat = g.AutoRepeatAttack;
+        if (renderer.Checkbox("Auto-repeat attacks", ref autoRepeat))
+            _vm.SetGameplay(g with { AutoRepeatAttack = autoRepeat });
+
+        bool toggleRun = g.ToggleRun;
+        if (renderer.Checkbox("Run mode is toggle (vs hold)", ref toggleRun))
+            _vm.SetGameplay(g with { ToggleRun = toggleRun });
+
+        bool advCombat = g.AdvancedCombatUI;
+        if (renderer.Checkbox("Show advanced combat UI", ref advCombat))
+            _vm.SetGameplay(g with { AdvancedCombatUI = advCombat });
+
+        bool vivid = g.VividTargetingIndicator;
+        if (renderer.Checkbox("Vivid targeting indicator", ref vivid))
+            _vm.SetGameplay(g with { VividTargetingIndicator = vivid });
+
+        renderer.Spacing();
+        renderer.Text("Display");
+        renderer.Separator();
+
+        bool tooltips = g.ShowTooltips;
+        if (renderer.Checkbox("Show item tooltips", ref tooltips))
+            _vm.SetGameplay(g with { ShowTooltips = tooltips });
+
+        bool sideBySide = g.SideBySideVitals;
+        if (renderer.Checkbox("Side-by-side vital orbs", ref sideBySide))
+            _vm.SetGameplay(g with { SideBySideVitals = sideBySide });
+
+        bool coords = g.CoordinatesOnRadar;
+        if (renderer.Checkbox("Show coordinates on radar", ref coords))
+            _vm.SetGameplay(g with { CoordinatesOnRadar = coords });
+
+        bool spellDur = g.SpellDuration;
+        if (renderer.Checkbox("Show spell duration on enchantments", ref spellDur))
+            _vm.SetGameplay(g with { SpellDuration = spellDur });
+
+        bool helm = g.ShowHelm;
+        if (renderer.Checkbox("Show helm on character", ref helm))
+            _vm.SetGameplay(g with { ShowHelm = helm });
+
+        bool cloak = g.ShowCloak;
+        if (renderer.Checkbox("Show cloak on character", ref cloak))
+            _vm.SetGameplay(g with { ShowCloak = cloak });
+
+        renderer.Spacing();
+        renderer.Text("Interface");
+        renderer.Separator();
+
+        bool allowGive = g.AllowGive;
+        if (renderer.Checkbox("Accept items handed by other players", ref allowGive))
+            _vm.SetGameplay(g with { AllowGive = allowGive });
+
+        bool lockUI = g.LockUI;
+        if (renderer.Checkbox("Lock UI (disable panel drag/resize)", ref lockUI))
+            _vm.SetGameplay(g with { LockUI = lockUI });
+
+        bool mouseTurn = g.UseMouseTurning;
+        if (renderer.Checkbox("Use mouse turning", ref mouseTurn))
+            _vm.SetGameplay(g with { UseMouseTurning = mouseTurn });
+
+        renderer.Spacing();
+        renderer.TextWrapped(
+            "Local-only this phase — values persist to settings.json but "
+            + "don't yet sync to the server. Server sync arrives in a "
+            + "follow-up phase.");
+    }
+
     private void RenderSection(IPanelRenderer renderer, string label, InputAction[] actions)
     {
         // Movement defaults open; other sections collapsed for first-run UX.