fix(search): tied scores — constant_score pages a mixed corpus like match_all, and every re-sort uses the one page-order key - #300

…atch_all, and every re-sort uses the one page-order key (fixes #270)

Two defects from #270, both reproduced at origin/main (c21d27a) with the
new tests before the fix.

1) constant_score on a mixed corpus returned a bounded page with no
   segment documents: 40 flushed + 300 unflushed identical docs,
   {"constant_score":{"filter":{"match_all":{}}}} at size:1 returned
   ["mem000"] where the full page starts ["seg0000"] (sizes 1/5/41/60/
   100/150/199 all violated the prefix property; totals were correct).

   Root cause is upstream of the early-outs the issue pointed at: the
   wrapper defeated `is_match_all`, and `try_shortcut_count` has no arm
   for a bare MatchAll (MatchAll totals are normally handled by the
   flag), so `count_authoritative` was FALSE and the stored scan ran in
   exact-counting mode — it tallies past a full collector but never
   materialises into it. With the memtable walked first, the bounded
   page was all memtable documents. The two breaks in
   `hydrate_prefiltered_unsorted` the issue flagged are gated on
   `count_authoritative` and get per-segment headroom (`scan_limit`)
   plus the #267 cross-segment re-merge, so they were never reachable
   in the failing configuration and are untouched.

   Fix: `is_match_all_effective` peels top-level `constant_score`/
   `boosted` chains for the count/bounds decisions only
   (`count_authoritative`, the final `live_doc_count()` total
   overwrite). Scoring keeps the raw flag; a top-level Constant's
   scores are overwritten with the wrapper boost before the page sort
   regardless.

2) Five post-sort re-sorts tied by `_id` alone — the bool-text IDF
   rescore, the near-zero-BM25 TF-IDF fallback, and the three
   `request.rescore` sorts — so any of them firing on a tied hit set
   reordered the page into `_id` ASC (measured: 40 flushed + 600
   unflushed, {"match":{"body":"listpack"}} → every score exactly 1.0
   via the TF-IDF fallback, page mem0000…mem0599 before seg0000…;
   the fallback fires at ~640 identical docs because BM25 IDF collapses
   to ln(1+0.5/(N+0.5)) < 0.001, and its recomputed score
   tf.sqrt()*(1+ln(N/df)) is exactly 1.0 for identical docs).

   Fix: hoist the main sort's decorate-sort-undecorate into
   `Index::sort_hits_page_order` (score DESC, seq_no ASC, _id ASC) and
   route the main default sort and all five re-sorts through it. Peer
   engines keep one comparator through collection, merge and final
   sort: Lucene HitQueue.java:76-82; tantivy
   collector/sort_key/sort_by_score.rs:105-109 (heap) vs :187 (final
   sort), same key; quickwit quickwit-search/src/collector.rs:1131-1156
   ties by GlobalDocAddress in both comparators (all read via the
   xerj-search reference corpus; no code copied).

Tests: tests/tied_score_resorts.rs (new; TF-IDF fallback, bool-text
IDF rescore, chained-rescore — all three failed at HEAD) and
constant_score added to the mixed-corpus case in
tests/tied_score_page_order.rs (failed at HEAD: size:1 → ["mem000"]).
The bool-text case asserts the full materialisation only: bounded
pages for multi-clause bools on a mixed corpus are selected under
first-pass scores where the memtable's uniform tf-sum differs from
segment BM25 — a scoring divergence (#188's remit) that admission hits
before any re-sort, documented in the test.

Gate: full xerj-engine suite green; ES-YAML conformance
1366 passed / 0 failed / 3 skipped on a private port (9475) with a
throwaway data dir.

Perf (uncached, query_cache cleared per iteration, 25k identical docs,
size:10, 200 iters, release; interleaved base/fixed runs):
- constant_score(match_all), 20k flushed + 5k unflushed:
  22.6 → 10.4 ms/query cold-cache order, 22.6 → 3.9 ms warm-cache
  order (the bounded scan replaces the full counting scan).
- match_all mixed: 8.6 → 8.7 ms (unchanged); term mixed measured in
  identical cache state: 4.63 → 4.60 ms (unchanged); fully-flushed
  fixture (the B7 hot path): all shapes unchanged (match_all 0.04,
  term 1.1, rescore 2.0-2.1 ms both builds). Apparent forward-order
  term/match_all deltas were cache-warming side effects of the
  preceding shape's scan no longer being O(N) — verified by reversed
  measurement order.
- rescore adds three ~page-sized decorated sorts: +0.1 ms at 256 hits.

Refs #191 (this closes the constant_score exclusion recorded there),
refs #267, refs #188 (bool-text bounded-page residual).