Which issue(s) does the PR fix:

#14173 introduced an optimisation to better handle regex patterns like .*-.*-.*. It identifies strings the pattern cannot possibly match (because they do not contain all of the literal values) and returns false from MatchString early.

However, if the string does contain all literal values, then the Go regex engine is used to confirm that the string does match the pattern. But this is not necessary in the case where the start and end of the pattern is .* and everything in between is either a literal or .*: if the string contains all of the literals in order, then it matches the pattern, and invoking Go's regex engine to confirm this is unnecessary and quite slow.

So this PR introduces a fast path for patterns like this.

I think we could apply something similar to patterns that don't start or end with .*, but this would be a slightly more complex change, and I wanted to keep this PR as small as possible while I get my head around FastRegexMatcher.

The existing FastRegexMatcher benchmark didn't cover the case where a pattern like .*-.*-.* matches the string, so I added a specific benchmark for this case:

goos: darwin
goarch: arm64
pkg: github.com/prometheus/prometheus/model/labels
cpu: Apple M1 Pro
                                        │   main.txt   │               pr.txt               │
                                        │    sec/op    │   sec/op     vs base               │
FastRegexMatcher_ConcatenatedPattern-10   3327.5n ± 1%   126.3n ± 2%  -96.20% (p=0.002 n=6)

                                        │  main.txt  │            pr.txt             │
                                        │    B/op    │    B/op     vs base           │
FastRegexMatcher_ConcatenatedPattern-10   0.000 ± 0%   0.000 ± 0%  ~ (p=1.000 n=6) ¹
¹ all samples are equal

                                        │  main.txt  │            pr.txt             │
                                        │ allocs/op  │ allocs/op   vs base           │
FastRegexMatcher_ConcatenatedPattern-10   0.000 ± 0%   0.000 ± 0%  ~ (p=1.000 n=6) ¹
¹ all samples are equal

Does this PR introduce a user-facing change?

[PERF] Improve performance of regex matchers like `.*-.*-.*`