…hods

LINK_LIBRARIES apparently isn't set for pure interface libraries, so we
weren't picking up some needed libraries found via interface targets
when building a bundled static lib; this fixes it by following
INTERFACE_LINK_LIBRARIES when we recurse into an interface library.

oxen-logging already requires this, and libquic and other deps are also
likely moving to c++20 in the near future.

The onionreq code requires nettle (for AES encryption).  If we are doing
a static deps build we'll already have it (via libquic deps), but
otherwise we need to find and link to it.

Fixes a compilation warning/error under clang+llvm.

- Add debian oldstable (bullseye)
- Add debian testing
- Use oxen repo for bionic

Remove `(amd64)` from various job names as its a sane default to assume
if not otherwise noted.

For shared builds we can use it rather than needing to rebuild ngtcp2.

bionic can't cope with the C++20 that we use.

Win (x86) build is broken for unknown reasons, so comment it out for
now as it isn't that important.

Catch2 gives more informative diagnostics when using CHECK(thing) or
CHECK_FALSE(thing) for direct boolean values.

Updated the network functions to be on a Network class
Updated the logic to store the quic::Network and quic::Endpoint instances
Added logic to store the current paths on the Network instance
Added a shared_ptr to the quic::connection_interface against it's associated path

- Fixes compilation failure when libquic comes from a system library,
  where we wouldn't get oxen::logging transitively via oxen-libquic.
- Fix `onionreq` target not explicitly depending on oxen::logging
- Remove oxen logging include from headers so that dependent code (e.g.
  an external cmake project depending on libsession-util) doesn't have
  to have it to include libsession headers.
- set OXEN_LOGGING_SOURCE_ROOT to strip the source directory out of
  logged source file paths.

This build is identical to the Static Windows x64 further down.

The Network object now manages an internal service node pool cache as well as the onion request paths needed for sending requests.

When calling `send_onion_request` it will check the snode pool (populating it if needed) and check for possible onion request paths (creating them if needed) before sending the request - these pool/path population approaches are blocking so the caller can trigger multiple requests and doesn't need to worry about multiple requests being triggered to populate the cache.

The Network object also has logic to persist and load this cache from disk (when initialised with a `cache_path`) in order to improve launch times after retrieving an initial cache.

Additionally the Network object exposes a couple of hooks so the client can register for updates to the onion request paths or the network connection status.

• Updated the service_node to inherit from RemoteAddress
• Added the ability to provide a custom timeout when making an onion request
• Standardised the log::level enums
• Finished function docs

• Replaced custom `service_node` with straight `oxen::quic::RemoteAddress` use
• Moved the failure count into a separate unsorted_map
• Got the tests working again

Avoids a duplicate submodule, but also avoids worrying about conflicting
versions between the local one and the one in libquic.

The spdlog callback_sink_mt is kind of gross to use: you get passed a
reference to an internal struct, and the sink's formatter gets
completely ignored (requiring you to maintain your *own* formatter
rather than the one that is right there).

This updates to a new oxen-logging commit that adds a
`formatted_callback_sink` that provides a nicer interface.  Other
related changes here:

- Remove oxen-logging and spdlog use from headers; if they are in the
  headers then they become obligatory dev packages for libsession-util
  itself (i.e. code trying to compile against libsession-util has to
  have oxen-logging and spdlog available, rather than have those remain
  private implementation details of libsession-util itself).

- The above required re-introducing a LogLevel that (somewhat)
  duplicates oxen::log::Level, but I tried to make it somewhat
  transparent and auto-converting to be easy to use.  (To do all that
  required making it a struct rather than an enum, but it works somewhat
  similarly to an enum class).

- Move the Network::add_logger out of Network to be a free function (not
  in the session/logging.hpp header) as the logging system is
  process-wide and isn't really specific to Network (we'll almost
  certainly expand it into other parts of libsession-util before too
  long).  This also means you can set up a logger *before* creating a
  network, to get early-Network log statements as well.

…cases

Wrapping these functions allow applications to control the log levels
without needing oxen::logging headers to be available.

- Remove some removed fields from the API comment
- Use a typedef for the snode/server req callback function (since it is
  the same for both calls), and document its fields.

We don't care about the specific numeric values underlying this enum, so
don't need to give them.  (It'll effectively be the same under the hood,
but by not giving them we signal that we just want different values, but
don't care what they are underneath, just that they are distinct).

If we don't wait for the disk thread to exit then we could end up
destroying the Network instance, but the disk writing thread also
depends on that instance and so we could end up destroying its
referenced `this` object out from under it.

This tweaks it to store the std::thread in Network rather than detaching
it so that we can re-join it (which waits for it to finish) before we
complete the Network destruction.

This also renames the disk thread function slight to
`disk_write_thread_loop` (from `start_disk_write_thread`) because the
function doesn't actually *start* the thread: it is just the infinite
loop body that the thread runs forever.

- prefer `<session/blah.hpp>` to `"session/blah.hpp"` in include/
  headers (that will get installed on the system) for referencing "full"
  header names, and use `"blah.hpp"` for relative header includes paths.
- remove some unused headers clang-tidy was warning about

Having it as an `int` with -1 meaning merged causes trouble with various
other code using it needing to compare it with size_t values.  Since it
really is an index, an optional<size_t> seems more appropriate and
avoids all the issues.

oxen-logging had a cmake cache variable, but it doesn't really work
properly (especially when multiple projects are trying to set it).  This
updates to a newer oxen-logging that replaces the cache variable with a
function to add the source dir reliably.

`oxen::quic::DEFAULT_TIMEOUT` is a std::chrono::seconds, so its
`.count()` is a seconds value, but the C API expects milliseconds here.

- oxenc::from_hex doesn't validate input (and requires that the input be
  checked with oxenc::is_hex if not already known to be hex).
- Switch to quic::parse_int for string-to-integer parsing as it's a big
  nicer than stoi in various input weird edge cases.

This file has a `using namespace oxen` now and dropping it reduces
verbosity (especially because most things in the oxen:: namespace are
subnamespaces already, like `log::` and `quic::`, so it doesn't really
pollute by doing so).