This implements a st3m-specific USB stack. It's effectively what
espressif provides with their esp_tinyusb component, but allows for
dynamic reconfiguration of the USB device.

This doesn't seem to be less performant than the rube goldberg we had
previously, but somehow fixes up rendering glitches.

Phew.

This was mostly blocked by Micropython, but it has since then also
upgraded to IDF 5: https://github.com/micropython/micropython/commit/e4650125b88a35f074097f16d84a8f49bd22ac06

We take that change and selectively apply it where necessary. However,
it's not a 1:1 patch apply, as we already were on a somewhat forked
Micropython, and we also want to support IDF 5.1, not 5.0.

We also bump up the IDF distribution brought in by Nix, and fix some
warnings that have since turned into errors due to toolchain changes.

We already moved LEDs to their own task. Let's try doing that for
jacksense too. As long as we don't run out of RAM this should be better
than having larger tasks, as things won't block eachother that much..?

1. Add locking (st3m_audio_* functions are now thread/task-safe).
2. Remove some duplicate code around speaker/headphones output.
3. Simplify applying audio volume to codec ('apply' function).
4. Small style stuff (bool, etc).

This moves all I2C addresses and locking logic into the BSP.

Previously MicroPython would mount LittleFS directly from the partition
by itself, using its own VFS stack.

This reconfigured the VFS layer in MicroPython to use POSIX
open/read/write/etc calls, which are backed by ESP-IDF. Now, instead of
managing (possibly multuple) block devices at different mountpoints,
MicroPython simply passes through all VFS access to the ESP-IDF VFS.

Then, we make the ESP-IDF VFS mount a wear-leveled FAT (backed by the
same partition which previously held LittleFS) onto /.

This is an annoyingly large change, but the gist of it is that we:

1. Move ctx into components/ctx
2. Move uctx into usermodule/mp_uctx.c
3. Split out uctx config into ctx_config.h and share it with the
   simulator.
4. Delete a bunch of unused ctx files
5. Flip some ctx bits for speed.
6. Draw the rest of the owl, ie. implement a dedicated rasterizer task
   in components/st3m.

This implements the 'crtc' part of the graphics stack, ie. the task
responsible for blitting out a set of framebuffers over SPI as fast as
possible.

Currently this is still single-buffered, as the micropython API needs to
be changed to support injected, per-frame ctx instances.