…R-2/6)

New `parallel_dispatch` module — the planner the agent loop's batch
dispatcher will consume in PR-4/5. Still passive: nothing calls
`plan_batch()` yet, so runtime behaviour is unchanged.

Module contents (`crates/librefang-runtime/src/parallel_dispatch.rs`):
- `ParallelPlan { groups: Vec<Vec<usize>> }` — output shape: each
  group's calls may run concurrently, groups themselves run in
  order. Concatenating groups yields 0..N (order preservation, a
  hard contract for Anthropic Messages API tool_result alignment).
  Helpers: `call_count`, `is_fully_sequential`.
- `NormalizedPath` enum: `Real(PathBuf)` for filesystem scopes
  (component-aware prefix overlap) and `Virtual(String)` for tool
  families whose scope is logical (`skill::<name>`).
- `lexical_clean` — folds `.` and `..` without touching the FS,
  since target files for `WriteScoped` calls may not yet exist.
- `paths_overlap` — `Real` paths overlap when one is a Path-level
  prefix of the other; `Virtual` overlap iff string-equal; mixed
  kinds never overlap.
- `extract_scope_path` — projects a `NormalizedPath` from a
  WriteScoped call's input. Handles `file_write` / `file_edit` /
  `apply_patch` (`path` field) and `skill_evolve_*` (virtual
  `skill::<name>` from the `name` field).
- `plan_batch` — contiguous-bucket scheduler:
  * empty / single → trivial.
  * any Exclusive → every call gets its own group (whole batch
    serialises).
  * walk in original order, accumulating into a `current` bucket.
    `WriteShared` flushes + owns its bucket (acts as a barrier so
    later ReadOnly calls cannot be reordered before it). `ReadOnly`
    appends. `WriteScoped` checks path overlap with the bucket's
    reserved scopes and flushes on conflict; an unprojectable scope
    is treated as a per-call bucket.

The barrier semantics are the key correctness property: if the model
emits `read /a, shell, read /c`, dispatching `[read /a, read /c] +
[shell]` would let the second read observe pre-shell state — exactly
what the model didn't intend. Contiguous bucketing keeps `read /c`
strictly after the shell.

Companion fix: `tool_classifier::classify_by_name` now matches the
`skill_evolve_` prefix and projects to `Mutating`. Without this PR-1
left those tools at `Unknown` -> `WriteShared`, defeating the virtual
scope projection that `plan_batch` relies on.

Tests: 14 new in `parallel_dispatch::tests`:
- order preservation helper `assert_plan_covers_all`
- empty / single-call shapes
- `three_reads_one_group`
- `read_plus_write_disjoint_one_group`
- `two_writes_sibling_files_one_group`
- `parent_child_overlap_splits`
- `component_aware_prefix_does_not_split` (`/a/b` vs `/a/bc`)
- `trailing_slash_and_parent_dir_normalise`
- `shell_exec_isolated_in_its_bucket` (barrier semantics)
- `interactive_forces_full_serial`
- `skill_evolve_virtual_scope` (same skill splits, different skills
  share a group)
- `write_scoped_without_path_is_isolated`
- `real_vs_virtual_paths_do_not_overlap`
- `lexical_clean_handles_dot_and_double_dot`

Plus 1 new in `tool_classifier::tests`:
- `skill_evolve_prefix_is_mutating` (covers all 6 concrete names +
  the bare `skill_evolve` non-match case)

Verification:
- cargo test -p librefang-runtime --lib -- parallel_dispatch
  tool_classifier: 39 ok (24 baseline + 14 new dispatch + 1 new
  classifier)
- cargo check --workspace --lib: clean
- cargo clippy -p librefang-runtime --all-targets -- -D warnings:
  clean

Stack: this PR is based on feat/parallel-tool-calls-m1 (PR #3127).
PR-3 will add `RuntimeConfig.parallel_tools` (feature flag); PR-4
wires `plan_batch` into `agent_loop.rs:3410`.