fix(ui): stop the reconcile ticks from destroying user state

The 4s reconcile tick was added to three long-lived surfaces. On two of
them it reloads by rebuilding every row instance, which silently threw
away whatever the user had built up since the overlay opened; on the
third it healed a row's data but left it in the wrong section.

- WorktreesOverview: LoadAsync clears Rows, SelectedCount, ConflictRows
  and BatchProgress, so batch-merge ticks, the highlighted row and a
  finished batch's outcome badges were wiped every four seconds --
  assembling a multi-worktree selection was impossible. Carry that state
  across the reload, keyed by task id, and re-point SelectedRow at the
  fresh instance (or clear it when the worktree is gone).
- MergeHelperSelection: the remember/restore had no re-entrancy guard, so
  a second tick entering between the first one's reload and its restore
  snapshotted rows already back at IsTickedByDefault and wrote that
  default back, re-ticking what the user had unticked. One tick at a time,
  and hold the row instances instead of a value snapshot so a tick landed
  during the await survives.
- TasksIsland: the tick deliberately never called Regroup because Phase 2b
  owned Rows in parallel. 2b has landed, so a healed task that went Done
  stayed in the Open section under a stale count, and a healed depends-on
  link never pulled its dependent under the chain head. Regroup when a
  patch moved a grouping input, gated on a cheap key so an idle tick stays
  free.

src/ClaudeDo.Ui/ViewModels/Modals/WorktreesOverviewModalViewModel.cs

@@ -112,7 +112,43 @@ public sealed partial class WorktreesOverviewModalViewModel : ViewModelBase
 
     private readonly System.Timers.Timer _reconcileTimer = new(4_000);
 
-    internal Task ReconcileTickAsync() => IsBusy || IsMerging ? Task.CompletedTask : LoadAsync();
+    // LoadAsync rebuilds every row instance from scratch and resets SelectedCount/ConflictRows/
+    // BatchProgress, so a bare reload on a 4s timer would wipe the user's batch-merge ticks, the
+    // highlighted row and a finished batch's outcome badges out from under them — assembling a
+    // multi-worktree selection would be impossible. Carry the state that is the user's (or a
+    // finished batch's) across the reload, keyed by task id; genuinely new rows come up unticked.
+    internal async Task ReconcileTickAsync()
+    {
+        if (IsBusy || IsMerging) return;
+
+        // Hold the row INSTANCES, not a value snapshot, and read them back only after the reload:
+        // a tick the user lands during the await happens before LoadAsync clears the collection,
+        // so the live instance still carries it.
+        var previousRows = AllRows.ToList();
+        var previousProgress = BatchProgress;
+
+        await LoadAsync();
+
+        var previous = new Dictionary<string, (bool Checked, BatchMergeOutcome Outcome, bool Selected)>(previousRows.Count);
+        foreach (var r in previousRows) previous[r.TaskId] = (r.IsChecked, r.MergeOutcome, r.IsSelected);
+
+        WorktreeOverviewRowViewModel? reselect = null;
+        foreach (var row in AllRows)
+        {
+            if (!previous.TryGetValue(row.TaskId, out var state)) continue;
+            row.IsChecked = state.Checked;
+            row.MergeOutcome = state.Outcome;
+            if (state.Outcome == BatchMergeOutcome.Conflict) ConflictRows.Add(row);
+            if (state.Selected) reselect = row;
+        }
+
+        // SelectedRow still points at a detached pre-reload instance either way — re-point it at
+        // the fresh row, or clear it when that worktree is gone rather than leave it dangling.
+        if (reselect is not null) SelectRow(reselect);
+        else SelectedRow = null;
+
+        BatchProgress = previousProgress;
+    }
 
     public void SelectRow(WorktreeOverviewRowViewModel row)
     {