Alternation

Implemented the | construct.
Anchors

Implemented the ^, $, \A, \Z, and \z constructs.
Look Around Fix

Fixed a bug which was causing negative look arounds to function as positive look arounds.
RegexEngine::AtBeginning

Added the AtBeginning method to the RegexEngine class, which determines whether the engine is at the beginning of the sequence against which it is trying to match.
RegexCompiler::IsNext Fix/Cleanup

Fixed a bug which was causing the RegexCompiler::IsNext method to incorrectly determine that certain strings were not next.

Also cleaned up the implementation thereof to reduce/eliminate duplicated code.
Word Boundaries

Implemented the \b and \B constructs, which match between a non-word character/the end/beginning of the string and a word character.
Last Match/Contiguous Matches

Implemented the \G construct, which matches either where the engine began within the string (the beginning for left-to-right mode, the end for right-to-left mode) or where the last match ended (i.e. it ensures matches are contiguous).
RegexState Flag-Handling Convenience Methods

Added two methods to the RegexState class:

- Set copies the CanBacktrack and PreventsBacktracking flags from the current RegexState to another RegexState
- Clear sets the CanBacktrack and PreventsBacktracking flags to false (as they are when the RegexState is constructed)
Regex::Iterable Fix

Fixed an issue which was causing all strings which required normalization to NFD to be treated as the empty string.

Regex::Iterable maintains two things internally:

1. A std::optional<String> which holds a string if the input string had to be normalized
2. Begin and end iterators in the form of const CodePoint * (as elsewhere throughout the library)

When an input string requires normalization, the std::optional<String> is engaged and populated with the normalized string.  The begin and end iterators should then be set to the begin and end iterators of that string, but they were instead both set to nullptr, causing the regular expression engine to attempt to match against the empty string (since begin==end, therefore the string is empty).
Backtracking Fixes

Fixed several problems with the way that backtracking was implemented, and the pattern elements that supported backtracking.

During backtracking, the RegexState::Rewind method was being invoked for each element before it was determined whether or not backtracking ended with that element.  This meant that when an element was invoked after backtracking, the engine had been rewound to the state it was in before the element was first invoked.

This didn't reflect the purpose/implementation of backtracking.  If the engine has been rewound to the state it was in before the pattern element matched, how does it make sense for the pattern element to match based on the state established from the preceding match?  The regular expression engine -- by calling Rewind -- expressed that it wished for that previous match not to have happened.  This logical flaw led to implementation complexity in derived class overrides of RegexPrivateState::Rewind.  A lot of logic and checking went into determining whether it was actually a rewind -- i.e. whether the internal state of the RegexPrivateState should be rewound -- or not.

Accordingly RegexEngines now invoke RegexState::Rewind only immediately before they delete a RegexState and move to the preceding pattern element.  Derived class overrides of RegexPrivateState::Rewind have been updated to reflect this, removing the complex logic present previously.

Moreover, some pattern elements were not properly updating the flags on their RegexState when called after backtracking.  Prevalently, the RegexState was not updated after a failure.  This caused the regular expression engine to loop infinitely, as the engine saw that the current element was flagged as being able to backtrack (from previous, successful matches), invoked it, and the element's internal logic dictated that it could not backtrack, causing it to fail, causing backtracking, ad infinitum.
RegexCompiler::Pop Problem/Inconsistency

The RegexCompiler class provides facilities to compile RegexPatternElements which are formed incrementally.  RegexLiteral is an example of such a pattern element: A contiguous string of literals -- i.e. code points/sequences which the regular expression engine should not interpret specially -- are aggregated into a single RegexPatternElement.  This has the advantage of reducing:

1. The number of virtual calls during pattern matching/execution
2. The number of heap allocations/deallocations which must be performed during compilation/teardown
3. The number of RegexState objects which must be pushed into a vector/backtracked over during matching/execution

However, the RegexCompiler::Pop method acted as though this mechanism did not exist.  This meant, for example, that when repetition constructs were added, the following regular expressions would've been treated as equivalent:

- (?:aaaa){4}
- aaaa{4}

Which is clearly bizarre, erroneous, and unintended.

The solution is to allow RegexParsers the opportunity to split RegexPatternElements up in response to a call to RegexCompiler::Pop.  This is accomplished through a new method on the RegexParser class -- GetLast -- which takes a reference to a RegexPatternElement, and returns a RegexCompiler::Element -- the result of abstracting the last logical RegexPatternElement.
Allow Integral Types to be Appended to Strings

Previously appending an object convertible to a string to a String depended on the presence of a String constructor accepting that type.  For most types this was not problematic as a templated constructor exists which takes any type which can be converted to a string.

However, given that overloads of operator << for both Strings and CodePoints are present, this was problematic for integral types.  Since the CodePoint class has a constructor which accepts any integral type, the conversion paths for an integral to CodePoint and String were equally favourable, leading to a compiler error.

Added a templated operator << which accepts any type convertible to String to rectify this.
Merge branch 'master' into regex

Merged master to obtain the new overload for String::operator <<.
RegexLiteralParser::GetLast

Updated the RegexLiteralParser and RegexLiteral classes to support/implement the RegexParser::GetLast method, which was implemented to solve a specific problem with them and to-be-implemented repetition constructs.