RegexEngine Constructor Parameter Order Consistency Tweak

Tweaked the order of parameters to the RegexEngine constructor to be loc, begin, end, rather than begin, loc, end, thus bringing it in line with the convention used by the rest of the library.
Regex Fix/Consistency Update

Brought the order of parameters to Regex::Match in line with the loc, begin, end convention used by the rest of the library.

Fixed a bug which was preventing the regular expression engine from forming matches at the end (in left-to-right mode) and beginning (in right-to-left mode) of the input string.
Regular Expression Execution Overhaul

Overhauled the Regex methods used to execute/evaluate regular expressions.

Previously a Regex::Match overload that took a pointer reference was used, however this model was insufficient and buggy -- under certain situations certain matches were not performed and further unwieldy out parameters would be required for it to maintain all the required state information.

Moreover, no facility was directly/conveniently supplied for lazy evaluation of the matches of a regular expression, i.e. for evaluating several -- but not all -- matches within a string.

Reimplemented the matching functionality within the Regex::Iterator class.  This is a ForwardIterator which lazily evaluates each match of a regular expression found in some string.

Added the Regex::Iterable class.  This class wraps a regular expression/string combination, providing begin and end methods which return Regex::Iterators and is a convenient target for range-based for loops.

Added the Regex::Iterate method overloads.  These are helpers which wrap the current regular expression and a string into a Regex::Iterable and return it.  This allows a Regex::Iterable to be easily obtained as the target of a range-based for loop.

The Regex::Match and Regex::Matches methods and overloads are now implemented in terms of range-based for loops and the Regex::Iterate method.
Regular Expression Compiler Group-Handling Improvements

There is now a method -- RegexCompiler::GetLastCaptureNumber -- for obtaining the last automatically generated capture number without causing that number to be incremented.

Modified the internal structures the RegexCompiler uses to store numbered and named capturing groups to accomodate the idea of pending references to a capturing group.

Certain regular expression constructs allow for arbitrary groups within a pattern to be recursed.  For this to be implemented, some kind of reference/pointer to the pattern element which implements that group must be obtained.  This is straightforward if such a pattern element has already been compiled, but if one has yet to be compiled matters are complicated.

Accordingly, the RegexCompiler now maintains a list both of pattern elements which capture a certain number/name, and of pointers which are waiting for the address of such a pattern element.  If the address of a pattern element capturing a certain number/name is requested and such a pattern element is present, the pointer-in-question is populated immediately.  Otherwise it is added to a list of pending pointers, and is populated when the compiler finishes.

If, at completion, there are any pending pointers which cannot be satisfied, an exception is thrown.

This functionality is exposed through the RegexCompiler::GetCapturingGroup overloads.