Also handle updates of playlist in a more sensible way, when requesting
the content or the info, also ask for the other when we think we need it

When creating a playlist with a name, now we returns its id so the
client know which playlist it just created.

- Query things by id and not names
- Modify LKT
- Handle things in amadeus

To visualize a specific playlist, we need to select it from the
playlists viewer. That thing is stored in the application and will be
viewed in place of the playlists' cards while selected, and won't be
stored in the navbar.

On the specific playlist viewer we can now deselect the playlist and go
back to the playlists' cards view.

- Let the TagKey be public, it simplify things
- Can query the epochs and change the way the thing is handle
- Remove no longer used file
- Update Amadeus accordingly

- Specialized structure for tags: we use a specific structure for the
  tags, where we handle the fact that some tags that are known can only
  apear once. We also try to avoid allocations if we have only one value
  for the tag.
- SmallVec to store languages and authors and owners in karas and
  playlists, because they won't be too many so try to avoir allocations
  as much as possible.
- We clean up a bit the code, and use something else than a macro to
  implement reading and checking a folder of hash-verified files…

Also, turn the binaries into lib+bin. We do this to try to begin their
compilation before the codegen finished for dependencies, specially for
zbus which takes a really long time.

We have a big refactor for the NKDB crate. We remove the queue from the
database. The queue should not be in the database. We place it in the
lektord crate. We also will place the search functionnalities out of the
nkdb or the lektord crate, and place it into a new one.

Also, update dependencies and run clippy.

Other developments:
- Update to amadeus
- Make the KId just a u64. This is just a simpler and better
  representation! The thing is Copy, we can use atomics and not bizarre
  mechanisms to factorize some Arc<str>, etc. We still can know when a
  kara was updated or the file changed, and we no longer need to
  factorize playlists. Note that the relation `RemoteKId <-> KId` is now
  a one-to-one relation.
- We also eepercutate the fact that KId is now copy in Amadeus. More
  things don't need clone anymore and the iterators now will return the
  KId and not a ref to it.
- Rationalize routes for lektord
- Update the returned data from kurisu API
- Change how to get, read or write the playlists and the queue.
- Add a separated epoch to playlists and the queue that is incremented
  each time we try to write it (controled by the methods.)
- Change the payload crates to reflect that
- Remove async_trait from where we can

- Use libcosmic (which is based on iced) for amadeus
- Cargo update + clippy
- logger updates
- Update badges & Readme

AMADEUS: Fix the flickering when offline + handle user token + kurisu token differently + Ensure correct scale factor when saving/loading config + Store retry time duration in config file

MISC: Cargo update & fmt & clippy & Move the git version things to the binary crates as the utils crate is not recompiled every time, thus versions might mismach

BUILD: Ensure that the source folder is mounted in the docker and don't package the base xcb libraries, let Qt depend on the system ones

LEKTORD: Don't clone the kara structure to serialize it just after in some routes, just directly serialize it

DATABASE: Avoid creating IDs for nothing if it didn't exist in the first place when kara query by id, also refresh playlists IDs on update to take the updated one