This provides minor compile-time optimization.

GCC is especially bad, as it had quadratic scaling in the number of
registered test cases in a TU, but Clang also scaled superlinearly, and
this commit fixes both.

AIUI:
1) Each `TEST_CASE` creates a separate global fragment to handle creating
   the `unique_ptr<ITestInvoker>`, moving the instance into AutoReg,
   destroying the old instance, etc, etc.
2) With optimizations enabled, the compiler merges all these global
   fragments into one big global fragment.
3) Then the compiler runs various optimizations passes on this new global
   fragment.
4) Because some of the passes scale superlinearly, the compilation times
   scale superlinearly in the number of `TEST_CASE` in a translation unit.

For bonus point, no optimization actually happens.

This commit fixes the problem (for non-LTO builds) by adding new `AutoReg`
constructor, one that takes the function pointer raw, instead of wrapped
in `ITestInvoker`. By delaying the construction of the `ITestInvoker`
into the outlined constructor, we no longer create big global fragments
for the compiler to optimize.

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.

This provides further speed-ups for TUs with many test cases templated
over the same set of types. For especially test-heavy (but still
realistic) TUs, the speed up is up to 20%.

This provides small (but measurable) improvements in compilation
times when a TU has multiple test cases templated over the same types.

We used to store a full vector of "views" of the registered test infos,
so that it can be retrieved externally. However, the only user of that
interface left was `Session`, specifically `Session::applyFilenameAsTags`.

By moving the adding of the filename tags into the `ITestCaseRegistry`
interface, we avoid storing the vector and make the initial test registration
faster.

The new code is ugly and shows a design/layering issue, but no worse than
the previous approach did.