fix(sidebar): make slot reconcile additive, rebalance on split

[rtalexk]

Context

Sticky sidebar slots mode shipped with three latent hazards that surfaced under heavy multi-window use:

1. Kill-pane cascades during hot paths. Show, Follow, PrepareWindow, and the after-new-window hook all reconciled the slot set on every fire, which meant a single kill-pane could fan out through backgrounded pane_closed / pane_exiting handlers, each running its own server-wide sweep. Under bursts (e.g. demux session connect <multi-window-config>) the cascade saturated tmux's command queue and froze input.
2. Rightmost pane ratcheted smaller on every sidebar open/close cycle. Tmux's default victim for a left -b split is the rightmost pane, but its default victim on pane removal is the leftmost-adjacent. The asymmetry compounded — open shrinks rightmost, close grows leftmost — so repeatedly toggling the sidebar slowly ate the user's chat / claude column.
3. demux session connect against a multi-window config stranded the sidebar. The new-window handler's Follow raced the legitimate client-session-changed handler's Follow during the launch burst, leaving the sidebar in the wrong window.

What does this PR do

• Additive-only slot reconciliation. Adds AddMissingSlots and routes Show, Follow, PrepareWindow, MaybePromoteSlot, and the after-new-window event through it. Slot eviction and dedupe now live exclusively in demux sidebar slots prune.
• demux sidebar slots prune subcommand. Reconciles the slot set on demand. Wraps the work in withHooksSuppressed, which clears after-kill-pane / pane-exited for the duration of the reconcile so its kill-pane calls do not cascade into a sweep storm. Snapshot is taken only after set-hook -gu succeeds (so a failed unset cannot leak doubled hooks on restore).
• Preserves env-tracked active sidebar across prune dedup. ReconcileSlots now takes a protectedPane parameter; when duplicates exist in the current window and one of them is the env-tracked sidebar, the protected pane wins. Without this, prune could yank the user's sidebar and cascade into UninstallSlots via the next Follow.
• Auto-promote slot on session change. MaybePromoteSlot (called from session_changed / window_focus handlers) activates the current window's slot when the client has no live sidebar tracked, without going through Show (which would Reconcile and kick off a cascade).
• Rebalance pane widths after sidebar split. splitSidebarPane snapshots pre-split widths, then issues resize-pane calls rightmost-first to restore them, so the leftmost original column absorbs the sidebar's footprint instead of the rightmost. Open/close cycles are now stable.
• session-connect race fix. launchConfigSessionAndConnect wraps only window creation in after-new-window suppression, restores the hook before tmux.Connect, so the legitimate client-session-changed Follow still fires.
• Drops dead LaunchAndConnectConfigSession and tightens stale comments around the rename.

Out of scope (known gaps, follow-ups)

• internal/sticky/reconcile.go:56 swallows errors from EnsureSlotInWindow in the install loop. Self-heals on next nav via AddMissingSlots, so left as-is.
• README troubleshooting does not link the slot placeholder SIGHUP / pty-leak rationale documented in cmd/sidebar.go:240-251. Doc polish only.

Manual QA

Sticky sidebar feature is per-client tmux state. Verify by opening tmux, attaching demux, and exercising each scenario against a live tmux server. Run all scenarios with [sidebar.sticky] slots = true set in ~/.config/demux/demux.toml.

Prerequisites

1. tmux >= 2.6 attached with demux hooks installed.

```bash
tmux -V
demux hooks install
tmux show-hooks -g | grep demux
```

Expect demux entries on after-new-window, after-kill-pane, pane-exited, client-session-changed, after-select-window, client-attached. If missing, rerun demux hooks install.

2. Slots mode enabled in config.

```bash
grep -A2 "sidebar.sticky" ~/.config/demux/demux.toml
```

Expect slots = true under [sidebar.sticky]. If not, edit the file or run demux config init and toggle it.

3. Built demux on this branch.

```bash
go build -o demux . && ./demux --version
```

Confirm the binary is from the current checkout.

Setup

Start with a clean slate so changes are observable:

```bash
demux sidebar hide # tear down any prior slots
tmux show-environment -g | grep DEMUX_STICKY
```

Expect no DEMUX_STICKY_PANE_* and no DEMUX_STICKY_MRU entries.

Scenario 1 — Sidebar open/close cycle preserves rightmost pane width

Reproduces the pre-fix ratchet on the rightmost pane.

1. In a fresh tmux window with two horizontal panes (nvim left, claude right, both ~80 cols), record widths:
   ```bash
   tmux list-panes -F "#{pane_id} #{pane_left} #{pane_width}"
   ```
2. demux sidebar show — sidebar appears as leftmost column. Re-list panes; expected: claude (rightmost) still has its original width, nvim (leftmost-adjacent) is original - sidebar_width.
3. demux sidebar hide. Re-list panes; expected: claude unchanged, nvim restored to its original width.
4. Repeat steps 2-3 four more times. Expected: claude width stays constant across every cycle. Pre-fix: claude shrinks by a few columns each cycle.

Scenario 2 — Multi-window session connect lands sidebar in the right window

Reproduces the session-connect race.

1. Add a multi-window session config:
   ```toml
   [[session]]
   name = "qa-multi"
   path = "~"
   [[session.window]]
   name = "a"
   [[session.window]]
   name = "b"
   [[session.window]]
   name = "c"
   ```
2. From a tmux client with the sidebar already shown (demux sidebar show), run:
   ```bash
   demux session connect qa-multi
   ```
3. After connect settles, the active window should be c (last defined). Confirm sidebar is in window c:
   ```bash
   tmux display-message -p "#{window_id} #{window_name}"
   tmux list-panes -t :. -F "#{pane_id} #{@demux_slot} #{pane_title}"
   ```
   Expected: at most one @demux_slot=1 row, the active pane is the user pane (not the sidebar).
4. Confirm no stranded duplicate slots elsewhere:
   ```bash
   tmux list-panes -aF "#{window_id} #{pane_id} #{@demux_slot}" | awk '$3==1'
   ```
   Expected: at most one slot per window.

Scenario 3 — Auto-promote slot on session change

1. With two demux-configured sessions A and B both having demux sidebar slots install run at least once, attach to A, run demux sidebar show, then close the sidebar pane manually via prefix x.
2. Switch to session B (prefix s, select B). Expected: the slot in B's current window automatically respawns as the active sidebar (you see demux --sticky running in the slot pane).
3. Verify env tracking:
   ```bash
   tmux show-environment -g | grep DEMUX_STICKY_PANE
   ```
   Expected: one entry, pointing at the now-active slot pane.

Scenario 4 — slots prune preserves the active sidebar across dedup (F1 regression)

Forces the corrupt-state case where the current window has two slot-tagged panes and the env-tracked one is not first-listed.

1. With sidebar shown, capture the active sidebar pane id:
   ```bash
   tmux show-environment -g | grep DEMUX_STICKY_PANE
   ```
2. Manually tag a second pane in the same window as a slot (simulating corruption):
   ```bash
   tmux split-window -h -d
   tmux set-option -p -t :.+ @demux_slot 1
   ```
3. Confirm two slot panes in current window, env-tracked one second:
   ```bash
   tmux list-panes -F "#{pane_id} #{@demux_slot}" | awk '$2==1'
   ```
4. Run demux sidebar slots prune.
5. Re-list slot panes; expected: exactly one slot pane in the current window, and it is the same pane id captured in step 1 (the env-tracked one).
6. Navigate to another window and back. Expected: sidebar follows correctly, no cascade into UninstallSlots (other windows still have their slots — check tmux list-panes -aF "#{window_id} #{@demux_slot}" | awk '$2==1').

Scenario 5 — new-window burst does not freeze tmux input

Stress-tests the additive invariant.

1. With slots mode active and an existing sidebar, rapidly create windows:
   ```bash
   for i in $(seq 1 10); do tmux new-window; done
   ```
2. Immediately try to type / send keys. Expected: tmux remains responsive throughout. Pre-fix: input could freeze for several seconds while the cascade drained.
3. After the burst settles, confirm slots populated additively:
   ```bash
   tmux list-panes -aF "#{window_id} #{@demux_slot}" | awk '$2==1' | sort -u
   ```
   Expected: at most one slot per MRU-reserved window, capped at MRUMaxLen (8 placeholders + 1 active sidebar).

Automated checks

```bash
go build ./...
go test ./...
gofmt -l .
```

All pass on this branch (204 tests in internal/sticky + cmd).