State-tracking on unique threads, decode op stub

This commit pushes state-tracking for each thread onto its own thread,
which removes that onerous state_mutex that had been causing so much
locking contention. As the first (still lump-y) commit along this path,
it breaks a few things, namely:

  o NO_PIPELINE probably doesn't work
  o async threads are all lock-free right now; this creates races
  o replay is now selectable and HAVE_REPLAY isn't working either

In addition, it adds the stub of an idea I've had for a while: A first
pass a run-time decompilation engine. Useful for debugging as pares the
state down to the relevant bits. I'm not 100% sold on the architecture and
I'd like to build something in that reports the net result as well, but
I'm not sure the best way to do that in the face of general instructions.

All that said, the pipelined no-replay case seems to work correctly. A
rough estimate compares to the previous best-case of no-pipeline no-replay
shows ~20% performance improvement. I also think I have discovered some
latent issues in the way that async was implemented that the previous
global state_mutex was hiding; ultimately this was probably a worthwhile
effort.

As a final note, this relies on a few C11 features. It's currently only
tested on Mac and probably (certainly) won't work on Linux (yet), but
that's just a matter of making some #defines more intelligent and/or time
as stdatomic.h and threads.h become available / supported.
Fixup async state.

Push the responsibility for managing control of recorded async state
to the peripherals themselves. Should have architected this way from
the beginning.

Add stubs for peripheral replay.
Need the wait for the ICE bridge to be fully init

Otherwise an attempt can be made to request an ICE function before
the object has been fully created --> segfault
add two decompiles to help debugging
Fixup NO_PIPELINE still no support for HAVE_REPLAY
Move !HAVE_REPLAY state_seek stub to state
Update a few more OP_DECOMPILES

Remove the addr/val game, it was cute but it fails to disambiguate
byte|halfword|word, and may cause issues if memory mapped i/o has
side effects on a read
Update to fix HAVE_REPLAY support

REPLAY should mostly be working now, with the notable exception of
things almost certainly breaking spectaculalry if an async event
happens while seeking through history, as there's no protection for
that case at all... (yet!)
Merge branch 'state_threads_stdatomic'

Pushes each logical unit completely onto its own thread. Fixes a series
of small issues that have likely been around for a while and were
previously masked by over-aggressive locking.

Should allow for increased run-time parallelism, although the units of
execution are so small that the actual benefit is certainly questionable.
Fixup cross-platform python detection, again

I think I've finally gotten it right this time