use papaya

[conradludgate]

Blocked on ibraheemdev/papaya#78

Papaya allows us to get lock-free lookups. This gives the following perf improvements:

old:

Timer precision: 41 ns
scoped               fastest       │ slowest       │ median        │ mean
╰─ paracord                        │               │               │
   ├─ get                          │               │               │
   │  ├─ t=1         13.53 ns      │ 33.15 ns      │ 15.32 ns      │ 15.31 ns
   │  ├─ t=2         19.9 ns       │ 30.45 ns      │ 24.61 ns      │ 24.78 ns
   │  ╰─ t=16        25.78 ns      │ 162.3 ns      │ 119 ns        │ 117.7 ns
   ├─ get_or_intern                │               │               │
   │  ├─ t=1         22.28 ns      │ 39.78 ns      │ 25.86 ns      │ 25.73 ns
   │  ├─ t=2         89.65 ns      │ 140.6 ns      │ 117.2 ns      │ 117.3 ns
   │  ╰─ t=16        1.155 µs      │ 2.843 µs      │ 1.709 µs      │ 1.753 µs
   ╰─ resolve                      │               │               │
      ├─ t=1         1.867 ns      │ 7.367 ns      │ 2.451 ns      │ 2.883 ns
      ├─ t=2         2.576 ns      │ 14.99 ns      │ 3.867 ns      │ 4.254 ns
      ╰─ t=16        3.367 ns      │ 38.74 ns      │ 4.409 ns      │ 5.175 ns

new:

Timer precision: 41 ns
scoped               fastest       │ slowest       │ median        │ mean
╰─ paracord                        │               │               │
   ├─ get                          │               │               │
   │  ├─ t=1         25.61 ns      │ 54.19 ns      │ 28.71 ns      │ 28.94 ns
   │  ├─ t=2         26.73 ns      │ 49.98 ns      │ 32.65 ns      │ 32.88 ns
   │  ╰─ t=16        35.78 ns      │ 124.6 ns      │ 40.21 ns      │ 47.91 ns
   ├─ get_or_intern                │               │               │
   │  ├─ t=1         35.61 ns      │ 67.86 ns      │ 43.15 ns      │ 43.49 ns
   │  ├─ t=2         149.8 ns      │ 213.4 ns      │ 173.5 ns      │ 173.9 ns
   │  ╰─ t=16        1.092 µs      │ 3.009 µs      │ 1.775 µs      │ 1.867 µs
   ╰─ resolve                      │               │               │
      ├─ t=1         2.488 ns      │ 11.69 ns      │ 3.613 ns      │ 3.884 ns
      ├─ t=2         3.072 ns      │ 9.239 ns      │ 4.821 ns      │ 5.064 ns
      ╰─ t=16        4.28 ns       │ 38.98 ns      │ 5.363 ns      │ 6.67 ns

There's a slight regression in the low-contention benchmarks. But in high contention, get is much faster on average due to not needing a read lock.

The get_or_intern case is largely unaffected, since we still use a sharded locking arena allocator.