Introduce deterministic property execution, built-in generators, shrinking, replayable seeds, and a separate Progmasoft-owned header API while preserving Catch2 compatibility targets and the C++14 engine baseline.

Add Bazel, Meson, Xmake, and Premake integration and tests alongside the existing CMake build. Replace Linux-only workflow coverage with Windows and macOS jobs and document the Catch2/Catch3 distinction.

The new implementation keeps track of found escape codes in a separate
vector, which has two advantages:
1) The handling of inputs without any escape codes is much faster. As
   this will be the case for majority of inputs, this should provide
   nice speedup all around.
2) We no longer mangle unrelated 0xFFs in the user-provided input.

Closes #3199

Catch2 defaults to random test execution order, which has to process
all tests present in the binary, even if they will be filtered down
to just 1 later. For the `SelfTest` binary, the overhead from this is
about 20% in Debug configuration and 5% in Release.

By registering the CTest tests with `--order decl`, we avoid this
overhead.

We generally do not even try to pretend to support more than plain ASCII,
because doing unicode in old C++ standards is a pain and a half. For
`toLower`, we used to wrap `std::tolower` with multiple casts to avoid UB,
but calling into it is relatively slow, and it tries to handle different
locales, which could cause unexpected results.

In addition, the new implementation is significantly faster, which helps
speed up the initial process bring up (as comparing tags, and thus test
cases is now faster).

The old implementation of String matchers worked by making a, potentially
lower-cased, copy of both the constructor arg, and the arg to `match` calls.

The new implementation does not make copies, and instead does per-character
lowering if needed. This is a win in **most** cases, with two exceptions:

1) Case-insensitive `Equals` between long strings. The old implementation
   is easy to autovectorize by the compiler, which wins over the extra copy
   with sufficiently long inputs.
2) Case-insensitive `ContainsSubstring` with inputs that trigger the worst
   case complexity of O(m*n) of the naive implementation.

The latter is fixable with some elbow grease by implementing a proper
string search algorithm, but the former is a cost we have to live with.

The goal is to do the equivalent of clobbering memory, which forces
the compiler to keep side effects that are external to the benchmarked
function, while allowing it to optimize inside the benchmarked function.

E.g. this cannot be optimized away:
```cpp
BENCHMARK("foo") {
    global_count += 1;
};
```

while this can:
```cpp
BENCHMARK("bar") {
    size_t local_count = 0;
    for (size_t i = 0; i < 100; ++i) {
        local_count += 1;
    }
};
```

Closes #2149