Contributes to #100315 (comment)

The probabilistic map uses an O(i * m) fallback for -Except methods (scan all the values for each character in the input).
We use the same O(m) helper (scan the values) to confirm potential matches in the vectorized helper.

This PR adds support for the probmap to use an O(1) contains check for -Except methods and match confirmations.
The check is effectively a perfect hash check entries[value % entries.Length] == value, but implemented using a variant of FastMod. These checks can be inlined into the vectorized methods while not consuming too much memory.
We use this only when the probmap is computed as part of SearchValues as finding an optimal modulus is relatively expensive (see ProbabilisticMapState.FindModulus - there are probably smarter ways to go about it). When the probabilistic map is created for single-use IndexOfAny operations, we still use the same O(m) checks as before.

This PR also replaces the Latin1CharSearchValues implementation with BitmapCharSearchValues, which can use a bitmap of arbitrary size (not limited to [0, 255]). We use this when we guess that it'll be faster than the ProbabilisticMap (e.g. there are a lot of values in the set, or the set is dense and the probmap isn't vectorized).
I haven't changed the condition when we use ProbabilisticWithAsciiCharSearchValues as there are plausible cases where the ASCII fast path may still be useful even if the probabilistic path could be a bitmap instead.

public class IndexOfAnyMixedAsciiNonAscii
{
    private static readonly SearchValues<char> s_charsWithNonAscii = SearchValues.Create("-0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyzK");
    private const string Text = "űaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";

    [Benchmark] // This one will do the confirmation inside the vectorized path
    public int IndexOfAny() => Text.AsSpan().IndexOfAny(s_charsWithNonAscii);
}

public class IndexOfAnyMixedAsciiNonAscii
{
    private static readonly SearchValues<char> s_charsWithNonAscii = SearchValues.Create("-0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyzK");
    private static readonly string _textExcept = new string('K', 1000);

    [Benchmark]
    public int IndexOfAnyExcept() => _textExcept.AsSpan().IndexOfAnyExcept(s_charsWithNonAscii);
}

public class IndexOfAnyMixedAsciiNonAscii
{
    private static readonly SearchValues<char> s_bitmap = SearchValues.Create(new string('\u0080', 256) + '\u0082');
    private static readonly SearchValues<char> s_probmap = SearchValues.Create(new string('\u0080', 100) + '\uF000');
    private static readonly string TextExcept = new string('\u0080', 1000);

    [Benchmark]
    public int Bitmap() => TextExcept.AsSpan().IndexOfAnyExcept(s_bitmap);

    [Benchmark]
    public int Probmap() => TextExcept.AsSpan().IndexOfAnyExcept(s_probmap);
}

This happens to bring all SearchValues<char> implementations to an O(i) worst-case (from O(i * m)).