A bunch of minor optimizations.

Seems to improve the hard case a bunch.
Here's benchcmp with and without:
benchmark                         old ns/op     new ns/op     delta
BenchmarkRegexpMatchEasy0x32      6111          6058          -0.87%
BenchmarkRegexpMatchEasy0x1K      48491         47084         -2.90%
BenchmarkRegexpMatchEasy1x32      4656          4676          +0.43%
BenchmarkRegexpMatchEasy1x1K      46373         43896         -5.34%
BenchmarkRegexpMatchMediumx32     4944          4979          +0.71%
BenchmarkRegexpMatchMediumx1K     78018         68761         -11.87%
BenchmarkRegexpMatchHardx32       511242        217892        -57.38%
BenchmarkRegexpMatchHardx1K       24128091      10082478      -58.21%

benchmark                         old MB/s     new MB/s     speedup
BenchmarkRegexpMatchEasy0x32      5.24         5.28         1.01x
BenchmarkRegexpMatchEasy0x1K      21.12        21.75        1.03x
BenchmarkRegexpMatchEasy1x32      6.87         6.84         1.00x
BenchmarkRegexpMatchEasy1x1K      22.08        23.33        1.06x
BenchmarkRegexpMatchMediumx32     0.20         0.20         1.00x
BenchmarkRegexpMatchMediumx1K     13.13        14.89        1.13x
BenchmarkRegexpMatchHardx32       0.06         0.15         2.50x
BenchmarkRegexpMatchHardx1K       0.04         0.10         2.50x
A dirty trick to get 35% improvement in hard case.

Instead of using a for loop to set seen to false, copy a pre-zeroed slice.
With and without:
benchmark                         old ns/op     new ns/op     delta
BenchmarkRegexpMatchEasy0x32      5976          5920          -0.94%
BenchmarkRegexpMatchEasy0x1K      44932         43565         -3.04%
BenchmarkRegexpMatchEasy1x32      4500          4700          +4.44%
BenchmarkRegexpMatchEasy1x1K      44136         43014         -2.54%
BenchmarkRegexpMatchMediumx32     4797          4832          +0.73%
BenchmarkRegexpMatchMediumx1K     66191         55345         -16.39%
BenchmarkRegexpMatchHardx32       209063        132596        -36.58%
BenchmarkRegexpMatchHardx1K       9699972       6112593       -36.98%

benchmark                         old MB/s     new MB/s     speedup
BenchmarkRegexpMatchEasy0x32      5.35         5.40         1.01x
BenchmarkRegexpMatchEasy0x1K      22.79        23.50        1.03x
BenchmarkRegexpMatchEasy1x32      7.11         6.81         0.96x
BenchmarkRegexpMatchEasy1x1K      23.20        23.81        1.03x
BenchmarkRegexpMatchMediumx32     0.21         0.21         1.00x
BenchmarkRegexpMatchMediumx1K     15.47        18.50        1.20x
BenchmarkRegexpMatchHardx32       0.15         0.24         1.60x
BenchmarkRegexpMatchHardx1K       0.11         0.17         1.55x
Cache machines in the Regexp.

Turns out this is where most of the time was going in the easy cases:
benchmark                         old ns/op     new ns/op     delta
BenchmarkRegexpMatchEasy0x32      5701          1328          -76.71%
BenchmarkRegexpMatchEasy0x1K      38737         33662         -13.10%
BenchmarkRegexpMatchEasy1x32      4365          1264          -71.04%
BenchmarkRegexpMatchEasy1x1K      37907         35337         -6.78%
BenchmarkRegexpMatchMediumx32     4732          245           -94.82%
BenchmarkRegexpMatchMediumx1K     50182         44875         -10.58%
BenchmarkRegexpMatchHardx32       127896        122713        -4.05%
BenchmarkRegexpMatchHardx1K       5861321       5887762       +0.45%

benchmark                         old MB/s     new MB/s     speedup
BenchmarkRegexpMatchEasy0x32      5.61         24.08        4.29x
BenchmarkRegexpMatchEasy0x1K      26.43        30.42        1.15x
BenchmarkRegexpMatchEasy1x32      7.33         25.31        3.45x
BenchmarkRegexpMatchEasy1x1K      27.01        28.98        1.07x
BenchmarkRegexpMatchMediumx32     0.21         4.07         19.38x
BenchmarkRegexpMatchMediumx1K     20.41        22.82        1.12x
BenchmarkRegexpMatchHardx32       0.25         0.26         1.04x
BenchmarkRegexpMatchHardx1K       0.17         0.17         1.00x