…ected length thresholds (#82457)

Followup to #82431

## Summary

The NavigateTo pre-filter gates whether fuzzy (edit-distance) matching
is attempted for a document. Previously it used only a
symbol-name-length bitset with a fixed ±2 delta — too coarse in
practice. In a large file with many 6-character symbols, searching for
"FooBar" (also 6 characters) would pass the length check for every
document, forcing an expensive full-scan fuzzy match against every
symbol in those documents even when the character content is completely
different.

This PR improves the fuzzy pre-filter in three ways:

1. **Correct the length check thresholds** to match what
`WordSimilarityChecker` actually enforces: ±1 for pattern lengths 3–4,
±2 for 5+, and no fuzzy matching at all for patterns shorter than 3.
Previously, the pre-filter used a blanket ±2 for all lengths and didn't
reject short patterns, which meant it was more permissive than the
actual fuzzy matcher.

2. **Add an exact bigram bitset** (38×38 = 1444 bits, 184 bytes per
document) storing all lowercased 2-character sliding windows of symbol
names. At query time, use the q-gram count lemma (Ukkonen, 1992) to
require a minimum number of shared bigrams: `min_shared = |pattern| - 1
- 2k`, where `k` is the edit distance threshold. If fewer pattern
bigrams match, the document is skipped for fuzzy matching entirely.

3. **Share threshold logic** by extracting
`WordSimilarityChecker.GetThreshold(int)` and `MinFuzzyLength` so the
pre-filter and the actual fuzzy matcher use the same constants instead
of duplicating magic numbers.

## Motivation

Consider a codebase with thousands of documents, many containing
6-character symbol names. When the user types "FooBar" in NavigateTo:

- **Before**: The length check passes for every document that has any
symbol of length 4–8 (±2). The caller then creates a `PatternMatcher`
with fuzzy matching enabled and runs it against every symbol in those
documents. Most of these comparisons compute edit distance only to
conclude there's no match.

- **After**: The length check passes (length 6, threshold ±2, checks
4–8). But the bigram check then asks: do at least 1 of the 5 bigrams
("fo","oo","ob","ba","ar") exist in this document? For documents with
symbols like "XyzWvq", none of these bigrams are stored, so the document
is skipped without ever creating a `PatternMatcher`.

## Bigram bitset design

Characters are mapped to a 38-element alphabet:
- `a`–`z` → 0..25
- `0`–`9` → 26..35
- `_` → 36
- everything else (Unicode) → 37 ("other" bucket)

This gives exact membership for the 37 most common identifier characters
and a single overflow bucket for rare Unicode characters. The bitset is
a `ulong[23]` (184 bytes) — compact enough to store per-document with
negligible memory overhead.

## Filtering effectiveness by pattern length

| Pattern length | k (threshold) | min_shared bigrams | Filtering power
|
|:-:|:-:|:-:|:--|
| < 3 | — | — | Fuzzy disabled entirely |
| 3 | 1 | 0 | No filtering (always passes) |
| 4 | 1 | 1 | Need ≥ 1 of 3 bigrams |
| 5 | 2 | 0 | No filtering (always passes) |
| 6 | 2 | 1 | Need ≥ 1 of 5 bigrams |
| 7 | 2 | 2 | Need ≥ 2 of 6 bigrams |
| 8 | 2 | 3 | Need ≥ 3 of 7 bigrams |
| 10 | 2 | 5 | Need ≥ 5 of 9 bigrams |

Lengths 3 and 5 get no bigram filtering benefit (min_shared = 0). For
length 3, we should strongly consider whether fuzzy matching itself is
too permissive to even support — with an edit distance threshold of 1, a
3-character pattern like "abc" would fuzzy-match "xbc", "axc", "abx",
"ab", "abcd", etc. This is a potential follow-up.

## Reference

Ukkonen, E. (1992). "Approximate string-matching with q-grams and
maximal matches." *Theoretical Computer Science*, 92(1), 191–211. [DOI:
10.1016/0304-3975(92)90143-4](https://doi.org/10.1016/0304-3975(92)90143-4)

The q-gram count lemma states: each edit operation can destroy at most
*q* q-grams from a string. Therefore, if `edit_distance(s, t) ≤ k`, then
at least `|s| - 1 - q·k` of s's q-gram positions must have a matching
q-gram in t. For bigrams (q=2): `min_shared = |pattern| - 1 - 2k`.

## Benchmarks:

| Method | Mean | Error | StdDev | Gen 0 | Gen 1 | Gen 2 | Allocated |
|-----------------------------------------------
|-----------:|----------:|----------:|------:|------:|------:|----------:|
| 'SameLen: LengthCheck pass (false positive)' | 0.9901 ns | 0.1123 ns |
0.0292 ns | - | - | - | - |
| 'VariedLen: LengthCheck pass' | 0.1914 ns | 0.0710 ns | 0.0184 ns | -
| - | - | - |
| 'SameLen: BigramCheck reject (true negative!)' | 7.1073 ns | 0.5302 ns
| 0.1377 ns | - | - | - | - |
| 'SameLen: BigramCheck pass (true positive)' | 7.1716 ns | 0.4179 ns |
0.0647 ns | - | - | - | - |
| 'SameLen: Combined reject (bigram saves)' | 28.2908 ns | 2.1554 ns |
0.3336 ns | - | - | - | - |
| 'SameLen: Combined pass' | 28.7838 ns | 1.3179 ns | 0.2039 ns | - | -
| - | - |
| 'SameLen: BigramCheck reject len=8' | 10.4243 ns | 1.4520 ns | 0.2247
ns | - | - | - | - |
| 'VariedLen: BigramCheck reject len=10' | 14.9580 ns | 0.7782 ns |
0.1204 ns | - | - | - | - |

---------

Co-authored-by: Cyrus Najmabadi <Cyrus Najmabadi>
Co-authored-by: Cursor <cursoragent@cursor.com>