Matcher: changed to use maps for tracking group matches (comments)

With this change we only keep the lowest char count for an OpenGroup, the highest for a CloseGroup, the longest match and only one Final/Accept state per tag.
NFA test: updated tests for new match state
Matcher - bug fix: Group tags were causing match fails

Any (Haskell) patterns that don't consume any of the string have to be matched before the fail on empty string.  This is a long standing bug where, for example, a pattern that ended with a group (even potentially, as in a group followed by a star expression) it could not match because empty string fail would match before the CloseGroup match was checked.  Even if we check CloseGroup first, that could still fail because the CloseGroup could hold a Split where one of it's clauses was a Final.  Since the Split wasn't broken down, the Final state wouldn't be seen even though it matches (Split consumes no characters).
Matcher: updated debugging pattern to work with the new List transformer
NFA test: added group matching predicates and a test
Matcher: cleaned up some naming of aux functions
NFA test: added two new tests for group and star interaction
Parser: moved group grammar location (comments)

This change creates the group structure that I was producing by hand, which I think is cleaner.  It will potentially cause multiple open groups per single close group (or no close group) but I think that's fine.

NOTE: this implementation contains a bug: if you have a structure like "^a(b|x)*c$" the created NFA will put the OpenGroup in the right place, in front of the b/x split.  The problem is, this consumes no input so it always matches, causing a 1 to be logged in the state for that group even if the group match ends up failing.  So if you match the above on a string like "ac" it will incorrectly report a group match of "(1,1)".  Of course a zero size capture is impossible and could be filtered, the issue comes from the underlying problem stated above and filtering out zero size captures only hides the issue, it will pop up in other locations.

To resolve this we either have to move the OpenGroup in such a way that it is only encountered after input from its group has been consumed or (much better) find a way to let a given traversal carry it's encountered Open/CloseGroups with it, so if the traversal fails entirely, those entries would all be dropped.
Matcher: reversed order of Monads to fix bogus group matching (comments)

Ok, so previously we had (ListT (StateT)), which meant the list monad with a state that was visible to all traversals.  This is not what we actually wanted as this caused one traversal to record an OpenGroup that another traversal used even though it didn't see that specific one.  What we actually wanted was the state to be only visible to a given traversal.  So to achieve this we simply reverse the monads.  List is now the "inside" monad and State the outside.  This has the effect that each traversal has its own state for bookkeeping, so there is no longer a danger of a traversal seeing a CloseGroup and using the OpenGroup of a totally different traversal.

NOTE: This does cause one bug, however.  Since the State is now only visible to a specific traversal, and not all of them, any matches that occur before the end of the string will be forgotten since match keeps running until the string is exhausted.  To fix this, we'll have to wrap what we have now around another state monad.  This new State will receive the "Results" data which will now have to include the final group results as well as the Accept state itself.
NFA test: fixed the predicates to work on the new returned structure
NFA test: added new capture tests that test new capabilities (comments)

Now that we can, I've added two tests that show off the power of the new grouping code.  These would not have worked before thanks to the probably of global state.