RegexEngine Current Location Fix/Improvement

Due to the fact that a match may begin anywhere within a string (if a match fails at the first location in the string, the match will be attempted again at the next location, et cetera) it is important due to the context-sensitive nature of some Unicode algorithms (and potential regular expression pattern elements, such as look around) that the context be preserved.

Accordingly the RegexEngine constructor no longer simply takes a begin and end iterator, rather taking a begin, location, and end iterator, meaning that the entire string will always be available for context-sensitive algorithms/pattern elements, but that the match may begin at an arbitrary location within that string.
RegexEngine Last Match Location

RegexEngines now track the point at which the previous match occurred, for the purposes of implementing the \G construct in the future.
Regex::Match Overhaul

Added a new Regex::Match overload which allows for streaming matching -- i.e. it takes certain iterators as out parameters, and updates them as the matcher works through the string, allowing successive matches to be obtained by successively calling the method.  The other Regex::Match overloads are now implemented in terms of this overload.

The Regex::Match overload which takes a begin and end iterator now accepts an optional locale parameter, which is used for normalization.

The Regex::Match overload which takes a string now uses the string's locale.
RegexMatch Cleanup

Cleaned up the implementation of the RegexMatch::operator [] overloads.
RegexMatch::Complete Fix

RegexMatch::Complete now also calls the Complete method of all contained RegexCaptures.
RegexEngine State Maintenance

Added the RegexEngine::Set method (and an overload), which allows a RegexEngine to automatically transfer relevant state to a RegexState or a RegexEngine object, simplifying the state maintenance process for pattern elements which use their own, internal RegexEngine.
RegexAtomic Fix

Fixed a bug which was causing RegexAtomic pattern elements not to appropriately advance the state of the RegexEngine.

RegexAtomic pattern elements use a RegexEngine internally to match against the pattern elements they maintain.  Accordingly the main RegexEngine (which the pattern element is passed as a parameter) must be fast forwarded after the RegexAtomic's internal RegexEngine completes, however this was not done.
RegexCompiler Capturing Group Support

Added capturing group support to the RegexCompiler class.

The RegexCompiler can now track all RegexPatternElements associated with a certain named or numbered capturing group, as well as automatically generating monotonically increasing capturing group numbers (beginning with 1).

Removed one of the RegexCompiler constructor overloads, as it was obsolete and maintaining it was becoming a nuisance.
RegexEngine Directionality Fix

Fixed a bug which was causing the location iterator of RegexEngine to always be created as a forward iterator.
RegexEngine Reverse Constructor

Added a constructor to the RegexEngine class which creates it by copying another RegexEngine (with a separate pattern), and optionally changes/sets its direction (i.e. forward or reverse).
RegexEngine::Rewind

Added the Rewind method to the RegexEngine class.  This rewinds each pattern element the RegexEngine has matched.

This is necessary for pattern elements which use a RegexEngine internally, can't backtrack, but may be backtracked over, as when they are backtracked over they must give contained pattern elements the opportunity to clean up.
Look Around

Implemented look around, i.e. the (?=), (?!), (?>=), and (?>!) constructs.