+1 is faster than succ
Attempt to speed up AutoUpdate for high concurrency.

The goal is to get rid of any situations where multiple threads will be
spawned due to concurrent calls to the action. To do this, we take
advantage of unsafePerformIO. This allows us to keep a single
atomicModifyIORef call, which will always either:

1. Get the current value from the AutoUpdated constructor.
2. Spawn a new thread and calculate a new value in a separate thunk, and
   *immediately* return a new AutoUpdated constructor so that future
   calls will immediately get the same generated value. However, since the
   value is in fact an IO action in a thunk, future threads will all block
   for that single value to be calculated. Since unsafePerformIO does
   automatically applies non-duplication, we know the action will only be
   run once.
3. Decide that it's not yet time to do automatic updating, and return a
   ManualUpdates with a Manual action.
No atomics at all
auto-update: only ever fork one worker thread

Goal: fork a single worker thread immediately, and have it sleep when
it's not needed.

Current code has a downside that after delay, the next time the value is
demanded there will be a lag before the value is available. That can be
fixed with an IORef, but I need to check if that makes performance
worse.
Code cleanup
Use atomic-primops for Counter
Switch timeout handling to atomic-primops

This is more experimental than the previous commit. Benchmarking is
necessary to see if the less readable code here is worth it.
Merge branch 'spawn-single-thread'
Version bumps