BitBox02 firmware

workflow/unlock: add unit test

api/backup: add unit test for creating a new backup when initialzed

keystore: add timeout reset in keystore_encrypt_and_store_seed

The duration of this function can go over the 500ms timeout duration,
so we give more time so the create/restore API calls don't timeout.

api/backup: yield to avoid timeout

Maybe not strictly needed, but to reduce the chance of comms timeout,
we yield after copy_seed.

sd: speedup sd_card_inserted

Don't sleep as long.

hal: make SD functions async and yielding

An SD operation resume clock, mount, does the operation, unmounts,
stops clock. This is a bit slow. In API calls like backup creation,
this happens 10+ times in a row, which can cause communication
timeouts.

We make all SD functions async. Instead of making all of them properly
async, for now we make all of them yield to the executor afterwards,
so the communication processing gets a chance to run and not cause a
timeout. In the future we could then swap the sdcard functions with
proper async ones.

cmake: CMake variable handling is a black box

bluetooth: use hex literal for the allowed Bluetooth FW hash

rust: add hex_lit dep

It's already in our vendor dir, and useful in tests to avoid
encoding/decoding hex at runtime, or to use ugly `b"\x..\x..\x.."`
literals. This commit changes a few instances for demo, but the idea
is that future tests can make use of it readily.

rust/keystore: make bip39 unlocking async

This uses `to_seed_normalized_async(...).await` over
`to_seed_normalized(...)` in bip39 unlocking, propagating the
async/await keywords up the stack.

This commit by itself is not functional yet, as the unlock animation
is still timer-interrupt based, which leads to chaos. The next commit
converts the animation into an async task of its own, not depending on
interrupts.

The bip39 unlock loop is made to yield to the executor in each of the
2048 PBKDF2 stretch rounds. In the simulator however, we don't yield
and finish the computation in a blocking fashion like before, due to a
limitation of the simulator: it does not busy-loop the
mainloop (otherwise CPU would be at 100%), but only when there is an
incoming USB packet, so yielding in BIP39 would make unlocking in the
simulator *very* slow. Running the mainloop quicker in the simulator
does not work well: either CPU load is too high, or unlock is too slow.

vendor: add rust-bip39 dep

We use our fork that has two custom patches:
- fix bitcoin_hashes transitive dep version to avoid duplicates
- add async version of the function to derive a bip39 seed

This will be used to convert our BIP39 unlock to be an async
operation, not blocking the mainloop.

rust: Apply -Werror if -Dwarnings

If user enables -Dwarnings via RUSTFLAGS also enable -Werror for C code
compiled by cargo/build.rs.

cmake: Read RUSTFLAGS from environment and propagate correctly

mock: Move wrap function to mocks from fakes

keystore: fewer securechip calls when checking password

The sanity check to see if the seed has changed does not need a
securechip operation, it can use the retained seed hash instead, same
as `unlock_bip39()`. This reduces the number of securechip operations
needed to do a password check, which reduces the risk of running into
the Optiga throttling security mechanism.

simulator: shutdown connection

TCP is fun. If the server initiates the closing of the TCP connection
the socket needs to stay alive for some time according to the protocol
so that out-of-order and delayed packets have a chance to arrive. When
the simulator gets shut down those packets doesn't matter. Luckily there
is a way around, by setting SO_LINGER on the socket the connection is
closed with a "RESET" instead and the socket is immediately released in
the OS.

This commit also switches from signal(2) to sigaction(2) so that we can
avoid setting SA_RESTART so that signals interrupt blocking syscalls
like read.

It also introduces support for "SIGHUP" that can be used to simply
disconnect the client.

jlink-scripts: reset before load

When using the watchdog it became clear that one must reset the CPU
before loading a new FW. It behaved very strange with the old order of
things.

ui: Remove noop

`.on_event` is allowed to be NULL

api/show_mnemonic: add unit tests

This also allows us to keep track of the number of secure chip
operations in all the scenarios.

hal: add show_and_confirm_mnemonic to HAL

The default implementation is in terms of other HAL/UI functions. For
unit tests (e.g. in show_mnemonic.rs or bip85.rs), it is useful to be
able to skip over the implementation details, so the tests don't have
to mock selecting the right words in the quiz.

workflows: use HAL for showing mnemonic and mnemonic quiz

`show_and_confirm_mnemonic(hal: ...)` did not use the HAL for all UI:
show_mnemonic and confirm_mnemonic directly used the BitBox02 menu
workflow without going through HAL. Can't use `hal().ui().menu(...)`,
becaus:

- these functions bolt a cancel prompt on top
- show_mnemonic is not a normal menu where one can pick an entry, it's
just a scroll-through for displaying the mnemonic

This should make it possible to mock/fake/test the mneomnic workflow
functions, and provide different implementations for them in future
BitBox hardware.

keyboard-switch: Force top location

The keyboard switcher is only used from the top so remove the option to
create it in the bottom location. This simplifies the event hander.

events: Remove unique events for top/bottom

Refactor code to get rid of more events. Inline the event slider data
into the event.

events: Remove events unrelated to sliders

Using events for communication between components in the same screen
seem to make things racy, simplify/sequentialize by using callbacks
instead.

Keep events only for external events like slider inputs.

ui: Remove components

* entry_screen isn't used
* confirm_button was just a trivial wrapper