* Just like the original LuaJIT interpreter, this will use a hook to automatically
  raise an error from Lua code.
* Unfortunately, as long as Jit compilation is enabled, this cannot reliably work.
  Therefore we still set an `interrupted` flag that must be
  polled from tight loops.
* Instead of polling via applause_push_sample() which gave interruption-support only
  to Stream:play(), we now have a separate checkint() function.
* checkint() should be manually added to all tight loops.
* Stream:foreach() and everthing based on it is now also supporting interruptions
  (via checkint()).
* This internally works via applause_is_interrupted().
  A C function was exposed only because LuaJIT does not support volatile-qualifiers and
  would optimize away reads to the interrupted-flag.
  As a side effect, we can also reset the hook.
* Flags set in signal handlers should be `volatile`.
* Added likely() and unlikely() macros to C code.
* Updated sample.ipynb Jupyter notebook: Everything important is now supported, albeit
  requiring custom ILua patches.

* This is at the very least cool to have and will be worthwile to write about in the dissertation.
* Added ilua-wrapper.sh script which can be used as the ILua interpreter and/or can be symlinked to `lua` in PATH,
  so ILua will pick up Applause even in Notebooks without any additional tweaks.

* Stream:CC14() allows reading 14-bit CCs (split over two 7-bit MIDI messages).
  It's actually capable to handle regular 7-bit controllers just fine.
  The question is whether we still need a distinction between Stream:CC() and Stream:CC14().
  Stream:CC14() has a slight overhead, but only when actually receiving MIDI messages.
* Stream:CC14() and Stream:CC() output values normalized to [-1,+1] now.
  We actually never made use of raw CC values and the scaling can be done only once whenever
  a matching MIDI message is received, so the runtime overhead is irrelevant.
* This means we could also get rid of Stream:ccscale() now.
  Just use Stream:scale() from nowon.
* Use Stream:scan() now whenever relying on previous values.
  That way, you can often avoid having to keep an accumulator variable in the closure.