Stops defining its own ignore knobs and reads from the existing
`editor.file-picker` config block (`hidden`, `parents`, `ignore`,
`git-ignore`, etc.) so a single set of rules governs both the
fuzzy file picker and the panel. `is_vcs_internal` keeps filtering
out `.git` plumbing regardless of config — that's structurally
never useful to surface.

Adds nerd-font glyphs for files and directories — chosen by extension /
basename via a small palette that's themable through `ui.filetree.icon.*`
scopes. Directory icons fall back through the file-icon palette so a
folder named after a recognized extension still gets a sensible glyph.
Icons live in a self-contained `icons` submodule (a 330-line palette is
clearly its own concern from birth) and the palette is consulted from
the entry row formatter.

Holding Alt at the start of a drag (`MouseEventKind::Drag` with
`KeyModifiers::ALT`) latches the gesture into copy mode rather than
move; the modifier is captured at drag-start so a later modifier
release doesn't reclassify mid-gesture (matching Finder / VSCode).
Files copy via `std::fs::copy`, directories via a new `copy_recursive`
helper that walks the source tree and re-creates it at the destination
without merging into an existing target.

Adds `a` (new file) / `A` (new directory) / `r` (rename) / `d` (delete)
keybindings and the matching context-menu items. Each pushes a `Prompt`
layer with input validation appropriate to the action — names rejected
for separators, NUL, or special-dot-dot; targets rejected for already-
existing paths; delete confirmed with a yes-prompt that distinguishes
files from non-empty directories.

The prompt-pushing and dispatching live in a new `ops` submodule
(so `filetree.rs` stays out of `ui::Prompt` plumbing) with the
filename / target-path validators in a new `paths` submodule
(closed-domain logic with exhaustive table tests). The cursor-row
"what does this action target" resolution joins the gestures
module as `resolve_action_dir`.

Press and hold on a row, drag onto a directory (or a file row that
resolves to its parent dir), release to `std::fs::rename`. The
dragged source row is dimmed during the gesture and the drop target
is highlighted, with files-row-resolves-to-parent-dir for the
"drop onto a file to land in its directory" UX.

Drag, click, and resize gestures cluster cleanly enough at this
point to earn a `gestures` submodule: `DragState` and the typed
outcomes `ClickOutcome` / `MoveValidity` live there alongside the
pure helpers (`classify_click`, `compute_resize_width`,
`validate_move`, `resolve_drop_target`) so the boundary cases are
unit-tested without faking a `Context`.

Spawns a notify watcher rooted at the panel root and refreshes
entries on filesystem changes. Path-classification (`is_noisy_path`)
filters out churn from typical workspace noise (`.git/objects`,
`target/`, swap files), and `watcher_action` decides whether a raw
event should rebuild entries, refresh VCS, or be ignored — both
live as pure functions in a `watcher` submodule so the noisy-path
boundaries and event-routing are unit-tested without a real
watcher.

Reads each entry's git status via `helix-vcs` and colors the row by
state (modified / added / deleted / untracked). Directories roll up:
a dir is highlighted by the strongest status among its descendants,
so a clean tree shows clean folders. The scan runs on a tokio
blocking task so a large repo never stalls the panel; results
trickle into a shared cache that the render path reads
lock-free.

Right-click on an entry opens a context menu with operations that
apply to it (open, reveal, copy path, …); right-click on blank space
opens a smaller menu rooted at the panel itself (refresh, change
sort, …). Navigation is keyboard or mouse; pressing the same key
again closes the menu. Lives in its own `context_menu` submodule —
the menu's data model, rendering, and event handling form a coherent
unit large enough to be its own concern from birth.

Tracks the most recent mouse position so the row under the cursor and
the resize-handle column get a subdued highlight (themed via
`ui.filetree.hover` and `ui.filetree.resize-handle.hover`), giving
mouse users an unobtrusive "this is what I'm about to act on" cue
before they click.

Press-and-drag on the column adjacent to the panel border resizes the
panel in real time, clamped between a configurable min/max and the
`min_remaining_editor_width` budget so the editor can never be squeezed
out. `compute_resize_width` lives as a pure helper so the boundary
math (clamps, position-aware sign) is unit-tested without faking a
Context.

Left-click selects the row under the cursor; a second click on the same
row within ~500ms activates (opens the file or toggles the directory).
Drag-out (release on a different row) cancels. The scroll-wheel pans
the viewport with buffer-scroll semantics — the cursor stays anchored
on its entry and only catches up when it would drift outside the
`scrolloff` comfort zone — matching how the editor scrolls buffers.

Click classification is factored out as a pure `classify_click`
returning typed `ClickOutcome` so the boundary cases (drag-out, second
click on a different row, threshold expiry) can be unit-tested without
faking a Context.

Adds a dot next to entries whose path matches an open buffer (with
directory rollup, so an ancestor of any open file gets the dot too) and
a render mode that auto-hides the panel when the terminal is narrow
*and* the panel isn't focused — pressing `<space>e` brings it back as
an overlay until focus drops again. The colon-passthrough comment in
the keymap is also updated to note that dropping focus is what triggers
the auto-hide.

The panel keeps its cursor on the focused view's current buffer at all
times — not just at focus-time — so it remains a live status indicator
of "where you are" while you work in the editor. When the panel itself
isn't focused, the cursor row is drawn in a subdued, bufferline-active-
derived style so the selection stays visible without competing with the
editor.

When `<space>e` (filetree_focus) lands the panel and the focused view has a
non-scratch buffer whose path lives under the panel root, expand every
ancestor directory and snap the cursor to that file's row so the next
`j`/`k` is relative to where you actually are. Scratch buffers and files
outside the workspace are silently skipped.

Lets <space> and `:` sequences route to the editor's keymap when typed
inside the panel by dropping focus on those keys (and leaving Helix's
own multi-key trie to handle the rest). The modal "unfocus, regain
with <space>e" shape matches the convention pickers already follow.

Reads the working directory into the panel, expands directories on demand
on Enter/Right, collapses on Left, and moves the cursor with arrow keys
and h/j/k/l. Opens files in the editor when activated.

Introduces a persistent filetree panel that can be opened on the left or
right side of the editor, with config, state, and a render skeleton in
place for subsequent features. Removes the modal file_explorer command
and key binding it replaces.