Close #62.

Mirror the fsevents PR #60 pattern: when 10+ sibling paths are registered
under the same parent, collapse them into a single watch on the parent
instead of opening one `ReadDirectoryChangesW` handle per child.

Implementation:
* Replace the `WatchMode` value of `self.watches` with a new `UserWatch`
  struct that carries the user's intent plus the resolved OS-level
  primary dir (and optional tracked-parent for `TargetMode::TrackPath`).
* Add `rebuild_watch_handles`: build a `ConsolidatingPathTrie` over the
  primary dirs from every user watch, compute the recursive flag per
  consolidated target by checking for strict descendants in the user
  watches, layer in tracked-parent watches that aren't already covered,
  and diff against the open `watch_handles` to converge the OS state.
* `add_watch` / `remove_watch` / `apply_staged` now update `self.watches`
  first and then call `rebuild_watch_handles` instead of poking
  `add_watch_raw` directly.
* The event filter at `handle_event` was a direct hash lookup on the OS
  dir name; consolidation can leave the OS dir different from any user
  request, so it now walks ancestors via `is_event_covered`.
* `pre_open_tracked_parent` works around a Windows quirk where calling
  `path.metadata()` on a directory *before* its parent dir has a
  `ReadDirectoryChangesW` handle silently drops the parent's later
  `FILE_ACTION_MODIFIED` event for that directory. The pre-call opens
  the tracked parent before any metadata is read, matching the order
  the previous per-call code used.

Adds five new tests covering: 10-sibling consolidation, event delivery
through a consolidated parent, mixed recursive/non-recursive collapse,
de-consolidation when the count drops back below the threshold, and the
batched `paths_mut().commit()` path.

The existing `windows_paths_mut` bench puts 40% of its files directly in
the tempdir root, so every watched parent dir consolidates back into
that root and the result is a single recursive watch on the entire
tempdir subtree. That hides consolidation's actual benefit — on this
workload consolidation is slightly slower because pre-opened handles
are immediately replaced.

The new `windows_sibling_subdirs` bench watches N sibling directories
under a shared parent, which is the shape issue #62 is about (e.g.,
watching each package directory in a monorepo, or each dependency
directory). With consolidation enabled this workload is 27–80% faster
than with consolidation disabled, with the win scaling as N grows.

…ed commit

`apply_staged` previously did a per-path `pre_open_tracked_parent` —
N opens just to satisfy the Windows metadata-quirk that requires the
direct parent to be watched before `path.metadata()` runs. Whenever
consolidation later collapsed those N parents into a higher ancestor,
all the pre-opens were thrown away (N closes + 1 reopen).

Replace the per-path pre-open with a single `pre_open_consolidated`
step that runs the same consolidation trie lexically over each staged
path's direct parent, opens the *consolidated* set, and picks the
recursive flag based on whether any staged parent is a strict
descendant of the consolidated target. The subsequent
`rebuild_watch_handles` against the actual primaries usually finds
the target already in place, so no close-and-reopen is needed.

On the existing `windows_paths_mut` bench, which collapses everything
into a single recursive watch on the test root because 40% of files
sit directly in it, this drops setup from ~13 OS ops to ~1. Measured
delta on `windows_paths_mut/nonrecursive/1000`: 21.37 ms → 20.78 ms
(-3%) and `windows_paths_mut/nonrecursive/100`: 2.60 ms → 2.09 ms
(-20%), bringing the consolidated path back to par with the
no-consolidation baseline while keeping the consolidation benefit.

The sibling-subdir workload — where consolidation actually saves
handles — also speeds up at the high end (`windows_sibling_subdirs/
nonrecursive/500`: 11.92 ms → 9.25 ms, -22%).

All 87 existing tests pass unchanged; the conservative open uses
exactly the same direct-parent invariant that `pre_open_tracked_parent`
relied on, so the metadata-quirk fix is preserved.