Add a test.

Just something that was worrying me, but it's fine.
Remove the bad implementation of Regexp.Match.
Re-implement Regexp.Match.

Fixes #18.

It's completely unoptimized yet still faster than the previous implementation on hard matches:
benchmark                         old ns/op     new ns/op     delta
BenchmarkRegexpMatchEasy0x32      1214          16776         +1281.88%
BenchmarkRegexpMatchEasy0x1K      32534         483739        +1386.87%
BenchmarkRegexpMatchEasy1x32      1203          16576         +1277.89%
BenchmarkRegexpMatchEasy1x1K      32699         477848        +1361.35%
BenchmarkRegexpMatchMediumx32     244           2093          +757.79%
BenchmarkRegexpMatchMediumx1K     40159         517059        +1187.53%
BenchmarkRegexpMatchHardx32       102727        73536         -28.42%
BenchmarkRegexpMatchHardx1K       4766294       1516938       -68.17%

benchmark                         old MB/s     new MB/s     speedup
BenchmarkRegexpMatchEasy0x32      26.35        1.91         0.07x
BenchmarkRegexpMatchEasy0x1K      31.47        2.12         0.07x
BenchmarkRegexpMatchEasy1x32      26.59        1.93         0.07x
BenchmarkRegexpMatchEasy1x1K      31.32        2.14         0.07x
BenchmarkRegexpMatchMediumx32     4.09         0.48         0.12x
BenchmarkRegexpMatchMediumx1K     25.50        1.98         0.08x
BenchmarkRegexpMatchHardx32       0.31         0.44         1.42x
BenchmarkRegexpMatchHardx1K       0.21         0.68         3.24x
Optimize.

Here's the improvement over the unoptimized version:
benchmark                         old ns/op     new ns/op     delta
BenchmarkRegexpMatchEasy0x32      16776         3496          -79.16%
BenchmarkRegexpMatchEasy0x1K      483739        91226         -81.14%
BenchmarkRegexpMatchEasy1x32      16576         3428          -79.32%
BenchmarkRegexpMatchEasy1x1K      477848        90250         -81.11%
BenchmarkRegexpMatchMediumx32     2093          688           -67.13%
BenchmarkRegexpMatchMediumx1K     517059        95195         -81.59%
BenchmarkRegexpMatchHardx32       73536         13852         -81.16%
BenchmarkRegexpMatchHardx1K       1516938       281635        -81.43%

benchmark                         old MB/s     new MB/s     speedup
BenchmarkRegexpMatchEasy0x32      1.91         9.15         4.79x
BenchmarkRegexpMatchEasy0x1K      2.12         11.22        5.29x
BenchmarkRegexpMatchEasy1x32      1.93         9.33         4.83x
BenchmarkRegexpMatchEasy1x1K      2.14         11.35        5.30x
BenchmarkRegexpMatchMediumx32     0.48         1.45         3.02x
BenchmarkRegexpMatchMediumx1K     1.98         10.76        5.43x
BenchmarkRegexpMatchHardx32       0.44         2.31         5.25x
BenchmarkRegexpMatchHardx1K       0.68         3.64         5.35x
Quickly skip runes that don't match a literal prefix.

With and without:
benchmark                         old ns/op     new ns/op     delta
BenchmarkRegexpMatchEasy0x32      3496          842           -75.92%
BenchmarkRegexpMatchEasy0x1K      91226         13973         -84.68%
BenchmarkRegexpMatchEasy1x32      3428          841           -75.47%
BenchmarkRegexpMatchEasy1x1K      90250         13950         -84.54%
BenchmarkRegexpMatchMediumx32     688           442           -35.76%
BenchmarkRegexpMatchMediumx1K     95195         21300         -77.62%
BenchmarkRegexpMatchHardx32       13852         14134         +2.04%
BenchmarkRegexpMatchHardx1K       281635        272032        -3.41%

benchmark                         old MB/s     new MB/s     speedup
BenchmarkRegexpMatchEasy0x32      9.15         37.99        4.15x
BenchmarkRegexpMatchEasy0x1K      11.22        73.28        6.53x
BenchmarkRegexpMatchEasy1x32      9.33         38.01        4.07x
BenchmarkRegexpMatchEasy1x1K      11.35        73.40        6.47x
BenchmarkRegexpMatchMediumx32     1.45         2.26         1.56x
BenchmarkRegexpMatchMediumx1K     10.76        48.07        4.47x
BenchmarkRegexpMatchHardx32       2.31         2.26         0.98x
BenchmarkRegexpMatchHardx1K       3.64         3.76         1.03x
Just call it a machine.
Remove dead code.
Merge pull request #21 from eaburns/re1

Implement a better Regexp.Match.

Here's a comparison with the old implementation:
benchmark old ns/op new ns/op delta
BenchmarkRegexpMatchEasy0x32 1214 842 -30.64%
BenchmarkRegexpMatchEasy0x1K 32534 13973 -57.05%
BenchmarkRegexpMatchEasy1x32 1203 841 -30.09%
BenchmarkRegexpMatchEasy1x1K 32699 13950 -57.34%
BenchmarkRegexpMatchMediumx32 244 442 +81.15%
BenchmarkRegexpMatchMediumx1K 40159 21300 -46.96%
BenchmarkRegexpMatchHardx32 102727 14134 -86.24%
BenchmarkRegexpMatchHardx1K 4766294 272032 -94.29%

benchmark old MB/s new MB/s speedup
BenchmarkRegexpMatchEasy0x32 26.35 37.99 1.44x
BenchmarkRegexpMatchEasy0x1K 31.47 73.28 2.33x
BenchmarkRegexpMatchEasy1x32 26.59 38.01 1.43x
BenchmarkRegexpMatchEasy1x1K 31.32 73.40 2.34x
BenchmarkRegexpMatchMediumx32 4.09 2.26 0.55x
BenchmarkRegexpMatchMediumx1K 25.50 48.07 1.89x
BenchmarkRegexpMatchHardx32 0.31 2.26 7.29x
BenchmarkRegexpMatchHardx1K 0.21 3.76 17.90x

Here's a comparison with Go's implementation ☺:
benchmark old ns/op new ns/op delta
BenchmarkRegexpMatchEasy0x32 129 842 +552.71%
BenchmarkRegexpMatchEasy0x1K 332 13973 +4108.73%
BenchmarkRegexpMatchEasy1x32 109 841 +671.56%
BenchmarkRegexpMatchEasy1x1K 1034 13950 +1249.13%
BenchmarkRegexpMatchMediumx32 201 442 +119.90%
BenchmarkRegexpMatchMediumx1K 72060 21300 -70.44%
BenchmarkRegexpMatchHardx32 3893 14134 +263.06%
BenchmarkRegexpMatchHardx1K 114819 272032 +136.92%

benchmark old MB/s new MB/s speedup
BenchmarkRegexpMatchEasy0x32 246.50 37.99 0.15x
BenchmarkRegexpMatchEasy0x1K 3083.54 73.28 0.02x
BenchmarkRegexpMatchEasy1x32 292.74 38.01 0.13x
BenchmarkRegexpMatchEasy1x1K 989.54 73.40 0.07x
BenchmarkRegexpMatchMediumx32 4.97 2.26 0.45x
BenchmarkRegexpMatchMediumx1K 14.21 48.07 3.38x
BenchmarkRegexpMatchHardx32 8.22 2.26 0.27x
BenchmarkRegexpMatchHardx1K 8.92 3.76 0.42x

The Go implementation is much faster for easy matches, because it has a more sophisticated algorithm for skipping literal prefixes.