Fix ripgrep compatibility issues #194–#201 - #202

…lags

Keep global -e/-f patterns given before the search subcommand (#194), let
a positive glob override a conflicting type filter like ripgrep (#195),
apply -t/-T in command-line order (#196) along with --type-add and
--type-clear (#201), make the last of -i/-s/-S win (#197), and accept
repeated -f/--file inputs alongside -e in order (#200). Ordered type
operations reach the server and shared daemon through a type_ops
parameter; clients require an ordered_filters acknowledgement before
trusting a reply whose result depends on that order.

Co-authored-by: Copilot App <[email protected]>

`-U --replace` now asks for `multiline_replace` only when the pattern can
match a line terminator. Any other pattern prints line by line, which an
older server already does. `--json --replace` no longer asks for
`report_replacements` with `-v` or `-q`, which print no submatches.

The acknowledgement check now reads the request, so it can never require
a field the client did not send. An older server's reply is then used
rather than refused for searches it renders identically.

Co-authored-by: Copilot App <[email protected]>

A server applied ripgrep's filter order to every request, so a client
that predates it, sending only `glob` and `types`, saw a positive glob
reinclude files its `-t`/`-T` had excluded. The client now sends
`ordered_filters` when its result depends on that order, and the TCP
server and shared daemons keep the old type and glob intersection for
requests without it. The client refuses a reply that does not
acknowledge the request, as before.

Co-authored-by: Copilot App <[email protected]>

ripgrep writes a file separator, and a context break before a block that
does not follow on from the last one, before it knows whether a multiline
rewrite leaves any row to print. A block the rewrite hides therefore keeps
its `--` (and its path with --heading), even at the end of the output.
tgrep already matches this on every backend; pin it with ripgrep 15.2.0's
output.

Co-authored-by: Copilot App <[email protected]>

ripgrep writes the `--` between files in one of two ways. Searching one
file at a time (under --sort, -j1 or on a single CPU), its printer writes
it as soon as a file reports a line, even if the rewrite then hides it.
Searching in parallel, it buffers each file's output and writes the
separator only before a buffer that holds something, so a file whose
-U -r rewrites print nothing adds no `--`. tgrep always did the former.

Hold a file boundary's `--` until the next file prints something, unless
ripgrep would search sequentially.

Co-authored-by: Copilot App <[email protected]>

`-m0` prints no lines, so `-U --replace` has no block to rewrite and
`--json --replace` has no submatch to report. Requesting either capability
anyway made a search fall back from an older server or shared view that
lacked it, for output that could not differ.

Also pin that an empty file reports no match under `-U --replace`, with or
without context, as ripgrep does: there is no zero-width match to keep.

Co-authored-by: Copilot App <[email protected]>

`-U --replace` only rewrites a file's matches as blocks when the pattern
can match `\n`. FileMatches::find answered that by parsing the pattern
into HIR again for every matching file, on the client and on the
server, so the cost grew with the number of `-f` patterns times the
number of matching files.

The linear-time matcher now works the answer out the first time it is
asked and keeps it, so a search parses its pattern once, whichever
thread gets there first. The `--multiline-dotall` flag the regex was
compiled with lives beside it, which retires the per-file
MatchOptions.dotall and the server's SearchOpts.dotall copies.

Co-authored-by: Copilot App <[email protected]>

Clap keeps only the deepest scope's values of a global flag, so the
reparse that rebuilds -e/-f, the type flags and the case flags in
command-line order has to cover every subcommand, not just `search`.
`--type-list` is honored under any subcommand, so
`--type-clear rust index --type-add rust:*.txt --type-list` listed an
empty rust type instead of `rust: *.txt` as rg does.

The reparse now makes those flags local at every level, nested `shared`
commands included, and reads each level of the subcommand chain in
order. It runs only when a subcommand is present and an ordered flag
was used.

Co-authored-by: Copilot App <[email protected]>

The line prescan from #102 assumed every match was non-empty and took
`end - 1` as the match's last byte. Patterns like `\b` and `\<` match
empty at a word's edge without matching `""` on their own, so they
reached it. An empty match at offset 0 underflowed, which panicked in
debug builds and printed lines twice in release builds, and one at a
later line's start gave a reversed range that dropped the line.

Each match now covers the lines from its start through its end offset.
That also covers the line after a match ending at a `\n`, where
`find_iter` skips an empty match at the previous match's end, like the
`\<` before `bbb` in `x\nbbb` for `\s|\<`.

Co-authored-by: Copilot App <[email protected]>