This argument already gets added when calling git_binary.run()

Now creating a worktree from a detached head also has remote support

GitStore::stage_all already does everything this method does and updates
pending_ops as well. So I'm removing this method to avoid a potential
foot gun in our codebase

- resolve_commit on Repository entity: wraps revparse_batch to check
  if a commit SHA exists in the repo. Used during restore to verify
  original_commit_hash is present before attempting recovery.
- repair_worktrees on GitRepository trait + RealGitRepository (runs
  git worktree repair) and FakeGitRepository (no-op). Used during
  restore when a worktree directory exists on disk but may not be in
  git's worktree metadata.
- repair_worktrees wrapper on Repository entity.

- resolve_commit on Repository entity: wraps revparse_batch to check
  if a commit SHA exists in the repo. Used during restore to verify
  original_commit_hash is present before attempting recovery.
- repair_worktrees on GitRepository trait + RealGitRepository (runs
  git worktree repair) and FakeGitRepository (no-op). Used during
  restore when a worktree directory exists on disk but may not be in
  git's worktree metadata.
- repair_worktrees wrapper on Repository entity.

Add the persistence layer for tracking archived git worktrees:

- ArchivedGitWorktree struct with staged_commit_hash and
  unstaged_commit_hash fields to precisely identify WIP commits
- DB migrations for archived_git_worktrees and thread_archived_worktrees
  (join table) tables
- CRUD operations: create, link to thread, query by thread, delete
- Column impl for deserializing ArchivedGitWorktree from DB rows
- Tests for create/retrieve with distinct SHAs, delete cascading
  through join table, multi-thread linking, and multiple worktrees
  per thread

Connect the git API and archived worktree data model to the sidebar's
archive/unarchive flow:

- Add thread_worktree_archive module: orchestrates the full archive
  cycle (WIP commits, DB records, git refs, worktree deletion) and
  restore cycle (detached worktree creation, reset to recover
  staged/unstaged state, branch restoration)
- Integrate into sidebar: archive_thread now persists worktree state
  before cleanup; activate_archived_thread restores worktrees via git
  with targeted path replacement for multi-root threads
- Show toast on restore failure instead of silent log
- Deserialize persisted project_group_keys on window restore
- Guard cleanup_empty_workspaces against dropped entities
- Await rollback DB operations instead of fire-and-forget
- If worktree already exists on disk when unarchiving, reuse it as-is
  instead of auto-generating a new path

persist_worktree_state:
- Read HEAD SHA before creating WIP commits as original_commit_hash
- Pass it to create_archived_worktree

restore_worktree_via_git:
- Pre-restore: verify original_commit_hash exists via resolve_commit;
  abort with user-facing error if the git history is gone
- Worktree-already-exists: check for .git file to detect if path is a
  real git worktree; if not, call repair_worktrees to adopt it
- Resilient WIP resets: track success of mixed and soft resets
  independently; if either fails, fall back to mixed reset directly to
  original_commit_hash
- Post-reset HEAD verification: confirm HEAD landed at
  original_commit_hash after all resets
- Branch restoration: after switching, verify branch points at
  original_commit_hash; if it doesn't, reset and create a fresh branch

Complete the thread archival refactor by implementing Phases 3-4:

Phase 3: Sidebar::archive_worktree (the executor)
- New async method that safely tears down workspaces, git state, and FS paths
- Prompts user to save/discard dirty items, racing against cancellation
- Closes workspace via MultiWorkspace::remove while retaining Project ref
- Iterates over roots: persists git state then removes worktrees
- Full rollback support: if any step fails or is cancelled, all completed
  persists are rolled back in reverse order

Phase 4: Sidebar::archive_thread (the orchestrator)
- Reads thread metadata to determine which roots need cleanup
- Filters out roots still referenced by other unarchived threads
- Creates cancel channel and spawns archive_worktree as background task
- Passes (Task, Sender) to ThreadMetadataStore::archive for tracking
- On success: cleans up completed archive entry
- On user cancel or error: automatically unarchives thread
- Preserves all existing focus management code

Additional fixes:
- Simplify ThreadMetadataStore::archive to accept pre-built (Task, Sender)
  instead of generic closure, removing unnecessary type parameters
- Fix pre-existing workspaces() API change (iterator vs slice)
- Fix pre-existing resolve_commit removal (deleted dead code path)
- Remove unused window_for_workspace helpers
- Add ArchiveStatus enum for distinguishing success vs user cancellation

Use futures::channel::oneshot for the archive cancellation signal and
futures::channel::mpsc::unbounded for the DB operations queue, replacing
smol::channel usage. Remove the smol dependency from the sidebar crate.

…xplicit drops

Rewire sidebar thread archival to start the in-flight worktree archive
task again, so archiving the last thread for a linked worktree removes
the worktree from disk instead of only updating sidebar state.

This also makes root planning and worktree-state persistence more
robust when a live linked-worktree repository handle is not already
available, and strengthens the sidebar test to assert the worktree
directory is actually deleted.

Restore smol::channel for the DB operations queue and archive
cancellation signal, reverting the futures::channel change from
e1c73e7. smol channels provide bounded backpressure and are a
better fit here.

Replace the old approach (git commit + git reset) with detached commits
via write-tree + commit-tree. This means the branch is never moved
during archival, eliminating the bug where WIP commits remained on the
branch after unarchive because git switch moved HEAD back to the
branch tip.

Archive: create_archive_checkpoint writes the current index tree and a
temp-index full tree as two detached commit objects, without touching
HEAD or the branch ref.

Restore: create worktree at original_commit_hash (branch unchanged),
switch to branch (no-op since it still points there), then read-tree +
git restore to reconstruct staged/unstaged state from the WIP trees.

Rollback: simplified to just deleting the git ref and DB record, since
no branch was moved.