daemon: use __attribute__((constructor)) for protolayer_globals

See merge request !1559

The `protolayer_globals` array can basically be treated as a constant by
most of the program and its initialization only uses compile-time-known
values.  We basically only initialize parts of the array in different
files throughout the codebase to maintain separation of concerns, so
that each piece of Knot Resolver initializes the part that pertains to
it.  Therefore, I believe that it is more ergonomic to just use
`__attribute__((constructor))` for these functions, so as not to pollute
`daemon/main.c` with these calls.

manager: directory cleaning

See merge request !1557

Added information about the development environment and code structure.

Debian packaging cleanup

See merge request !1555

This addresses dpkg-gencontrol warnings:

    dpkg-gencontrol: warning: Depends field of package knot-resolver6-module-http: substitution variable ${shlibs:Depends} used, but is not defined
    dpkg-gencontrol: warning: Depends field of package knot-resolver6-dev: substitution variable ${shlibs:Depends} used, but is not defined

-dbgsym packages are now generated automatically.

fixes lintian warning: not-binnmuable-all-depends-any

manager: use image from 'knot-resolver-ci'

See merge request !1554

This was forgotten during the CI overhaul.

Remove unused dependency and Dockerfile

See merge request !1553

Remnant of the past. This has been since replaced by images from
the `knot-resolver-ci` repo.

The library was used by the old experimental `kresc` client, which has
been removed in favour of Manager's `kresctl`.

Protocol layers and other parts refactoring (+ nits)

See merge request !1546

As pointed out by @lukas.ondracek, the wording could be confusing when
mentioning *bottommost* and *topmost* layers. The original wording was
meant to reference the way the arrays in `daemon/session2.c` are laid
out, but never explicitly mentioned that, so one could be implicitly
think it was in reference to the widely known ISO/OSI or TCP/IP models,
which could be interpreted incorrectly (the layers are traditionally
laid out the other way around there).

This allows us to use the newest versions of linter tools.

There were a few bugs in the protolayer system that prevented us from
pausing iteration and resuming it properly. This commit should hopefully
resolve them.

A) Context-specific allocations
-------------------------------

There were two problems:

1) Some payloads are short-lived (e.g. allocated on stack) and we need
   to make a copy of them if the iteration over protocol layers becomes
   asynchronous.
2) The `pl_dns_stream_wrap` function used a mempool belonging to its
   session-wide context. Some sessions may live for a long time, which
   could potentially lead to needlessly long-lived memory allocations.

Both of these problems are solved in this commit by using a new
`knot_mm_t pool` field in `struct protolayer_iter_ctx`, which lives only
for a single submit (and survives asynchronicity). The whole pool is
then freed all at once when the `struct protolayer_iter_ctx` is
finalized.

B) Merging `struct protolayer_manager` into `struct session2`
-------------------------------------------------------------

It actually made no real sense to have the two separated. It only
introduced an extra layer of indirection and many layers actually needed
to access both anyway. This should simplify things considerably.

Previously, PROXYv2 handling was partially implemented in the `io.c`
unit in the `_TCP` and `_UDP` protocol layers, which technically made
very little sense. This commit moves this handling into separate
`_PROXYV2_DGRAM` and `_PROXYV2_STREAM` protocol layers, basically
encapsulating the handling of proxies in the `proxyv2.c` unit.

This commit also makes the PROXYv2 stream layer only support
`PROTOLAYER_PAYLOAD_WIRE_BUF` on its input, as other payload types were
unused and untested in this context.

This makes some readability enhancements to the `protolayer_` API as
well as clarifies some of the documentation.

There is also a change where the definitions of protocol layer sequences
does not require a `_NULL` layer to be present at the end anymore, as
the number of layers in a sequence is determined at compile time. This
makes defining new sequences less error-prone.