ref(pattern): Replace regex based matching

[Dav1dde]

Replaces the regex fallback for complex patterns with a matching strategy using the parsed tokens.

The algorithm is loosely based on the one described by Kirk J Krauss. With some modifications, for example it does not use two loops and has support for character classes as well as alternations.

The implementation beats the current one of regex_lite in the added "complex" benchmark:

complex_match/case_sensitive
                        time:   [106.17 ns 106.28 ns 106.40 ns]
                        change: [-97.290% -97.284% -97.277%] (p = 0.00 < 0.05)
                        Performance has improved.
Found 3 outliers among 100 measurements (3.00%)
  2 (2.00%) high mild
  1 (1.00%) high severe
complex_match/case_insensitive
                        time:   [858.73 ns 859.23 ns 859.82 ns]
                        change: [-80.108% -80.027% -79.948%] (p = 0.00 < 0.05)
                        Performance has improved.
Found 23 outliers among 100 measurements (23.00%)
  1 (1.00%) high mild
  22 (22.00%) high severe

When comparing it with the regex crate, it's 2x slower for case sensitive and 8x slower for case insensitive.

There are still a lot of performance improvements to be found, some of them are annotated in code and more can probably easily found by running a profiler. Especially the case insensitive code paths are very expensive.
But this is something for future PRs.

The code is fuzzed with:

$ cargo +nightly fuzz run is_match_case_sensitive
$ cargo +nightly fuzz run is_match_case_insensitive

With full (expected) coverage in wildmatch (except for the impossible condition(s), like nested alternates).

[loewenheim]

Looks great. The very thorough comments definitely help.

[jjbayer]

Out of curiosity, does #[inline(always)] actually bring a performance improvement in the places where you added it?

https://std-dev-guide.rust-lang.org/policy/inline.html#what-about-inlinealways

[Dav1dde]

I didn't and usually I would just rely on the compiler (which is still allowed to ignore a inline(always)). I added it here to hopefully force a more aggressive monomorphization which hopefully leads to a better codegen. It's specifically also added on internal helpers.
A lot of 'hopefully's in there, but it should (another Konjunktiv) only make it better not worse.

[jjbayer]

I assume we could implement a special is_prefix_ignore_case ourselves?

[Dav1dde]

Yes. I essentially conceded to this implementation for now, because it was the easiest to get working. This is definitely a place where we potentially can get a lot of performance with a better implementation. A better impl here will also benefit is_prefix (it's essentially the same code).