RegexCharacterClass Backtrack Support

Due to the nature of Unicode and canonical matching/comparison, single code points may expand before being compared (regular expression patterns are not normalized, but the input strings being matched against are).

What this means for the RegexCharacterClass class is that RegexLiterals within the character class may consume more than one code point.

This means that backtracking becomes a relevant concept, since a character class which consumed one code point may have another match which consumes two code points.

Accordingly, implemented backtrack support for the RegexCharacterClass class.
Remove Unneeded Include From regexengine.cpp

Removed #include <new> from regexengine.cpp.

As what is now RegexIterator was once in this file, the new header was required, however no longer.
RegexRange

Added the RegexRange class.

This implements the [a-z] structure, i.e. it is a pattern element which matches a numerical range of code points within a character class.
RegexState Improvements

Improved the interface/implementation of the RegexState class:

RegexState's constructor now takes a const RegexEngine reference, rather than taking a RegexIterator.  This simplifies the interface/invocation and allows more information from the RegexEngine to be harvested into the RegexState during construction in the future, if required.

RegexState::Rewind now rewinds the nested RegexPrivateState -- if any -- before rewinding the RegexEngine.  This is more intuitive, as the RegexEngine will be in the state in which the creator of the RegexPrivateState left it when RegexPrivateState::Rewind is invoked.
RegexCompiler Additions

Added several methods to the RegexCompiler class:

- Size determines how many RegexPatternElements have been compiled into the RegexCompiler
- Pop retrieves the last RegexPatternElement added, and removes it
- Create creates a RegexPatternElement in the same way that Add does, but without adding it to the pattern
- An Add overload adds a std::unique_ptr<RegexPatternElement> (AKA RegexCompiler::Element) without actually creating it, enabling the caller to create the std::unique_ptr<RegexPatternElement> externally (for whatever reason)

Modified the templated Add method so that it is implemented using the newly-added Create method.  This centralizes related functionality -- see: DRY.
RegexCharacterClass Overhaul

Overhauled the implementation and design of regular expression character sets so that they would comply with the specification given here:

http://msdn.microsoft.com/en-us/library/ms994330.aspx

ToString methods not yet implemented.
RegexCharacterClass ToString

Implemented the ToString methods on both classes used to implement regular expression character sets.
RegexMatch and RegexCapture

Added the RegexCapture class, which encapsulates a single capture performed by a regular expression capturing group, and the RegexMatch class, which encapsulates the result of a single match of a regular expression.
RegexMatch Support

Added RegexMatch support to the RegexEngine class.

RegexEngines now carry a reference to a RegexMatch, which RegexPatternElements can then add to/modify.

Also added a new constructor to the RegexEngine class, which takes another RegexEngine and a collection of RegexPatternElements, the newly constructed RegexEngine then has the same logical state as the RegexEngine it was constructed from, but it matches a different pattern.

This greatly simplifies the construction of RegexEngines to match subpatterns.

Also added a Match method (and one overload) to the Regex class, which actually performs a regular expression match.
RegexCompiler Copy Constructor

Added a faux copy constructor to the RegexCompiler class.

This constructor does not actually copy the RegexCompiler-in-question -- due to the nature of std::unique_ptr, RegexCompilers are not copyable -- but rather copies all the information the compiler contains, except the pattern it's compiled and related state.

This greatly simplifies the creation of compilers to compile subpatterns, as in regexcharacterclass.cpp, where the creation of a compiler to compile character sets was greatly simplified.
regex.hpp Missing Include

Added an explicit include for the utility header to regex.hpp, which uses std::forward from that header, but was lacking an explicit include.
RegexCompiler::IsNext

Added the IsNext method (and overloads) to the RegexCompiler class.  These methods abstract away the common task of discovering whether or not some code point or string begins at the current location within the pattern.
Regex::Match Cleanup

Cleaned up the code which wrapped invocation of the RegexMatch::Complete method within the implementation of Regex::Match.
RegexCharacterClass Fix

Fixed a bug in the RegexCharacterClass class which was causing backtracking to loop infinitely.

When backtracking, the RegexCharacterClass should select the pattern element after the pattern element which matched previously, and start attempting to match from there.  However it was instead selecting the pattern element which matched previously, causing an infinite loop as it formed the same match over and over again.
RegexAtomic

Added the RegexAtomic class and supporting classes, which implement the (?>) construct -- a group which cannot be backtracked over, i.e. which is "atomic".