Make install paths quieter and clearer so pinned installs are easier to use
and verify. Accept bare version tags, print a compact install summary, and
capture the README/changelog updates plus shell formatting config that support
that flow.

* feat(cli)!: fix task/built-in collisions; merge exec into run

Built-in subcommands used to shadow same-named tasks: `runner clean`,
`runner install`, etc. ran the built-in even when the project defined a
matching task, and the `run` alias binary inherited the same clap parser
so `run clean` was broken too.

Route `runner <name>` through the task when a task with that name is
defined in the detected project. Any built-in-specific flag
(`--frozen`, `-y`, `--include-framework`, `--raw`, the `completions`
shell positional) still forces the built-in path as the escape hatch.

The `run` binary now uses a dedicated `RunAliasCli` parser (no
subcommands), so every positional argument is always routed through
`cmd::run` — built-in names never win against tasks.

Fold `runner exec` into `runner run`: when no task matches, `cmd::run`
falls back to executing the target as an ad-hoc command through the
detected package manager (`npx`, `pnpm exec`, `bunx`, `cargo`,
`uv run`, …), which is what `exec` did. The standalone `Exec`
subcommand is removed.

* fix(completions): native path completion + emit for run alias

Three zsh-completion fixes wrapped into one.

1. Tilde / named-dir expansion now works for --dir. The clap_complete
   engine does Rust-side directory listing that doesn't know about
   zsh's `~`, `~named-dir`, `cdpath`, or globs, so `run --dir ~/proj`
   and `run --dir ~pr/` returned zero candidates. Mark --dir with
   ValueHint::DirPath, detect path-typed flag values in
   GroupedZsh::write_complete, and emit a `__CLAP_PATHFILES__`
   sentinel so the zsh adapter can hand off to the native `_files`
   builtin.

2. Stop leaking shell options (XTRACE especially) into our completer.
   Add `emulate -L zsh` at the top of the function so caller-side
   settings reset to zsh defaults with local scope — matches the user
   report of `__runner_g='--dir <PATH>'` trace lines appearing at the
   prompt.

3. `run` binary lost its completions when it stopped sharing clap's
   parser. Refactor `runner completions <shell>` to call
   `EnvCompleter::write_registration` directly for both `runner` and
   `run` (one `eval "$(runner completions zsh)"` in .zshrc now
   registers both). Resolves the sibling `run` binary alongside the
   `runner` executable so the generated script points at an absolute
   path when installed side-by-side; otherwise falls back to bare
   `run` on $PATH.

* fix(dispatch,run): address review feedback

- Bare `runner` always shows built-in info. Previously the `None |
  Some(Info) if has_task("info")` guard routed even argv-less
  invocations to a user-defined `info` task, removing the default
  project summary. Narrow the guard to only `Some(Info)`.
- Drop Deno from the PM-exec fallback in `cmd::run`. `tool::deno::
  exec_cmd` produced `deno run <target>`, which treats `target` as a
  local script file rather than an arbitrary package binary —
  `runner run eslint` on a Deno project would misfire. Fall through
  to direct `Command::new(target)` so PATH is authoritative; remove
  the now-unused helper.
- Apply `cargo fmt`.

* fix(cli,complete): scope flag-hint lookup to active subcommand

- Correct the RunAliasCli doc comment: the parser treats the *first*
  positional as the task/command and forwards any remaining positionals
  to it as args (so `run foo bar` = run the `foo` task with `bar`, not
  two executable targets).
- Replace the unconditional recursion in `find_long_value_hint` with
  a two-step lookup: first parse the active subcommand chain from the
  completion args, then search only along that chain (deepest first,
  so subcommand-local definitions shadow the root). Prevents a future
  sibling subcommand with a clashing `--long` + different `ValueHint`
  from leaking into the wrong context. Added a regression test with
  two siblings defining the same `--out` long flag with different
  hints.

Rustfmt comments from the same review were already resolved in
ea1deea — no action needed on HEAD (`cargo fmt --check` is clean).

* fix(completions,run): narrow PM-exec fallback + guard run registration

- `runner completions` no longer emits a `run` registration when the
  sibling `run` binary isn't next to the current executable. A bare
  `run` completer would either hijack completion for an unrelated
  `run` on the user's PATH or fail silently when invoked. `runner`
  always gets its registration; `run` is added conditionally.

- Drop Cargo from the PM-exec fallback in `cmd::run`.
  `tool::cargo_pm::exec_cmd` produced `cargo <target>`, which
  dispatches to a cargo subcommand/plugin (`cargo eslint` →
  `cargo-eslint`), not an arbitrary PATH binary like `npx` does. For
  Rust repos with no matching task, fall through to
  `Command::new(target)` so `runner run eslint` behaves consistently
  with the other ecosystems. Remove the now-unused
  `tool::cargo_pm::exec_cmd` helper.

- Declare MSRV explicitly (`rust-version = "1.88"`) to reflect the
  let-chain syntax used throughout the codebase (stabilised in
  1.88.0) and to give Cargo a compile-time tripwire for older
  toolchains.

* fix(complete,cli): walk the active chain for value-flag detection

- Rewrite `long_flag_takes_value` to search the active command chain
  (root → current) instead of `current + current.subcommands`. The old
  implementation's flat_map over subcommands could falsely claim that a
  flag takes a value because a *sibling* subcommand defines it — then
  over-consume the next token during chain construction. The
  chain-based search matches clap's actual parsing precedence:
  ancestor globals plus current-level locals, never sibling locals.
  Added a regression test covering a root-level value flag being
  correctly recognised after descending into a subcommand.
- Derive `Debug` on `RunAliasCli` for symmetry with the `Command`
  enum.

* fix(complete): honour deepest-first shadowing in value-flag lookup

`long_flag_takes_value` used `.any()` across the full chain, so an
ancestor definition could override a subcommand-local redefinition.
When root defines `--flag <value>` and a subcommand redeclares `--flag`
as `SetTrue`, the walker wrongly consumed the next token as a value
while inside the subcommand. Mirror the deepest-first resolution used
by `find_long_value_hint`: iterate the chain in reverse, stop at the
first arg whose long name matches, and base the boolean on *that*
arg's action. Added `detect_path_files_honours_boolean_shadow_on_subcommand`
to pin the behaviour.

* fix(complete): route ExecutablePath to zsh's executable-only glob

- `zsh_files_flags(ValueHint::ExecutablePath)` now returns `-g *(*)`
  instead of the empty string, so `_files` uses zsh's `(*)` glob
  qualifier to surface only files the current user can execute.
  Previously the hint silently degraded to "any file".
- `grouped.zsh` now `setopt noglob` inside the sentinel branch before
  splitting the flag string, so the `*(*)` token reaches `_files`
  literally rather than being glob-expanded at our call site.
- Added `zsh_files_flags_map_each_path_hint` covering every variant we
  care about (path-like + a couple of non-path ones).
- Added `cli_has_no_short_value_taking_flags` as a tripwire for the
  short-option assumption in `active_command_chain`: if anyone wires
  up `-x <value>` on either CLI the test fails and the walker has to
  grow real short-option handling first.

* chore(release): 0.4.0 — collision fix + exec/run unification

- Bump `runner` to 0.4.0 and fill in the CHANGELOG section. 0.3 →
  0.4 because the PR contains breaking CLI changes (`runner exec`
  removed, `runner <name>` shorthand prefers a same-named task over
  built-ins like `install` / `clean`).
- In `cmd::run::run_pm_exec_fallback`, replace the eager `combined`
  allocation with a closure that's only invoked inside the PM-dispatch
  arms. The direct `Command::new(target)` fallback (Deno, Cargo,
  Poetry, Pipenv, Bundler, Composer, Go, no-PM) no longer pays for a
  vec it never reads.

* feat(completions): add --output/-o to write script to a file

`runner completions [<SHELL>] [--output <PATH>]` now writes to `<PATH>`
instead of stdout when given, with a stderr confirmation line on
success. Default (no flag) behaves exactly as before. An existing file
is overwritten; missing parent directories surface as an actionable
"failed to create …: No such file or directory" error rather than a
bare io::Error.

Teaching the short-form: `-o <VALUE>` is the first short option in the
CLI that takes a value, so `active_command_chain` and
`detect_path_files_flags` gained short-option siblings to their
existing long-option handling. Both use the same deepest-first
shadowing rule as their long counterparts, and both forms of short
usage (`-o value` across two tokens, `-oVALUE` in one) now route
through zsh's `_files` when the arg has `ValueHint::FilePath` et al.

Factored the `-SetTrue / -SetFalse / -Count / -Help / -Version / …`
"boolean action" check into a shared `action_takes_value` helper to
keep `long_flag_takes_value` / `short_flag_takes_value` in sync. The
old `cli_has_no_short_value_taking_flags` tripwire — which existed
specifically to guard against the short-option handling gap that's now
closed — is replaced by three positive tests exercising separated,
attached, and boolean short-option cases.

`cmd::completions` got a `write_registrations` helper so the
byte-for-byte output is identical between the stdout and file paths.

README usage block and CHANGELOG (0.4.0 Added) updated.

* chore(tooling): format extension-less scripts via shfmt

- Register `install-branch`/`run`/`runner` with dprint through shfmt
  so the extension-less wrappers get the same formatting as `*.sh` files
- Reformat `bin/{run,runner}`, `install.sh` to tab indent and
  parameterise `bin/run` and `bin/runner` via a `BIN` variable
- Add `bin/install-branch` helper to `cargo-install` from a/the current
  git branch
- Tidy `Cargo.toml` field ordering and add tombi `lint-disable` hints