Change the FastSet implementation for Attoparsec.Text to use a HashTable

I have reimplemented the Text FastSet as a minimal hashtable. In my testing this seems to be more efficient than binary search at all sizes, but it is definitely faster for very large sets. I have used simple Robin Hood hashing which has good density and cache locality, but it might be worth checking out perfect hashing or cuckoo hashing. I also moved around and added to the tests for this section of the codebase.

I have the following benchmarks to back me up;

Before:


    benchmarking headers/T/request
    time                 51.76 μs   (51.67 μs .. 51.89 μs)
                         1.000 R²   (1.000 R² .. 1.000 R²)
    mean                 51.85 μs   (51.74 μs .. 52.03 μs)
    std dev              430.6 ns   (305.5 ns .. 634.6 ns)
    
    benchmarking headers/T/response
    time                 75.14 μs   (74.91 μs .. 75.44 μs)
                         1.000 R²   (1.000 R² .. 1.000 R²)
    mean                 75.06 μs   (74.94 μs .. 75.20 μs)
    std dev              428.2 ns   (343.1 ns .. 575.5 ns)
    
    benchmarking headers/TL/request
    time                 127.3 μs   (126.8 μs .. 127.8 μs)
                         1.000 R²   (1.000 R² .. 1.000 R²)
    mean                 127.3 μs   (127.1 μs .. 127.6 μs)
    std dev              890.7 ns   (680.9 ns .. 1.204 μs)
    
    benchmarking headers/TL/response
    time                 164.4 μs   (163.7 μs .. 165.4 μs)
                         1.000 R²   (1.000 R² .. 1.000 R²)
    mean                 164.6 μs   (164.3 μs .. 165.2 μs)
    std dev              1.551 μs   (1.118 μs .. 2.415 μs)

After: 

    benchmarking headers/T/request
    time                 36.97 μs   (36.79 μs .. 37.22 μs)
                         1.000 R²   (1.000 R² .. 1.000 R²)
    mean                 36.65 μs   (36.56 μs .. 36.78 μs)
    std dev              364.3 ns   (244.7 ns .. 619.3 ns)
    
    benchmarking headers/T/response
    time                 46.79 μs   (46.59 μs .. 46.98 μs)
                         1.000 R²   (1.000 R² .. 1.000 R²)
    mean                 46.62 μs   (46.51 μs .. 46.73 μs)
    std dev              387.9 ns   (307.1 ns .. 529.5 ns)
    
    benchmarking headers/TL/request
    time                 119.0 μs   (116.5 μs .. 120.9 μs)
                         0.998 R²   (0.998 R² .. 0.999 R²)
    mean                 115.7 μs   (114.8 μs .. 116.8 μs)
    std dev              3.258 μs   (2.487 μs .. 4.360 μs)
    variance introduced by outliers: 25% (moderately inflated)
    
    benchmarking headers/TL/response
    time                 137.8 μs   (133.4 μs .. 142.4 μs)
                         0.996 R²   (0.994 R² .. 0.999 R²)
    mean                 138.3 μs   (136.9 μs .. 140.1 μs)
    std dev              5.573 μs   (4.568 μs .. 6.813 μs)
    variance introduced by outliers: 39% (moderately inflated)



Thanks,

Sean