feat: implement cdc application layer, fix enumeration

feat: atomic register modifications

fix: usb should not rewrite DIEPCTL bits

feat: add rx data callback, increase tx fifo size

fix: make queue thread safe

fix: ensure register access are inline

tests: add device descriptor test

This is just an initial skeleton of
how the tests could look like.
It's proving hard to think of a good
way to encapsulate the tests. Every
test will need a different set of files
from the project compiled, as some
files should be stubs instead. Additionally,
those stubs could have some commonalities.
It should for example be possible to initialize
the usb device from the tests. It would be good
to implement at least some basic handling
of the usb registers as well. - ie. if you
enable an endpoint and put in data through fifo,
the endpoint should be disabled. It should be
possible to send data from the host to the device
as well - reading from fifo. And stuff like that...

chore: fix packing on x86_64

chore: add gcc toolchain to compile tests

fix: correctly send functional descriptor

The functional descriptor was not sent correctly,
specifically, it was pointed to its address,
instead of the pointer itself. That meant bunch
of irrelevant stuff was sent instead.

feat: use task_result to indicate blocking

There should be no spin loops inside of the
interrupts, so this change removes them,
and instead uses a result system that has
WOULD_BLOCK result. When this result is returned,
it is expected there was no side-effect and the
function can safely be reran later.

feat: implement enumeration fully

chore: update pin, exti, delay

fix: fifo has to be volatile

docs: add documentation comments to most functions

feat: implement usb devicd cdc descriptors, init, setup

feat: move all sending instructions to generic send functions

fix: make sure to error if endpoint id not found in interrupt

This generally shouldn't happen,
but it needs to be ensured that the
memory at incorrect place won't be read
or written to!
Otherwise there could be undefined behavior!
This would possibly write to the fifos,
meaning the data the usb sends could be
different than what the application intended!

fix: clear bit operation

feat: implement most of enumeration