Actor Collector Pinning Refactor

[fhilgers]

This change is rather large.
To summarize the problem at hand:

Aya allows us to own maps via take_map but only allows us to borrow
program (program, program_mut).
Owning maps has another problem, we can never put them back, so we have
to keep them safe forever.

Io operations are inherently falliable, meaning that when we are reading
from one of our maps, there is always the possibility of some unxpected
error.

In our collectors and config handlers, each instance is responsible for
their own ebpf maps, meaning there is no overlap:

VfsWriteCollector => VFS_WRITE_EVENTS
SysSendmsgCollector => SYS_SENDMSG_EVENTS
VfsWriteFeature => vfs_write, vfs_write_ret, VFS_WRITE_PIDS

That means that our collectors and handlers should own the maps and
programs exclusively both performance wise (no locking) and
semantically.

This is

1. Not possible with programs, because aya forbids it
2. Prone to losing maps

In the case of a panic or error, we would have to try and bubble up our
maps so that they are not lost.
This leads to a much more complicated design.

Ebpf maps and programs can be pinned to the file system. This is not
only interesting for us in the future (hot restart without losing any
data because ebpf is still collecting) but also interesting for us now.

We can set the relevant maps to be pinned and load all ebpf programs on
startup, pinning them to the ebpf file system. Afterwards we can use the
pinned objects and construct our registry.

Through that we could in theory have many references on a single object.
To forbid that and ensure exclusive access we can use AtomicCells.

The crossbeam crate offers a AtomicCell which is lockfree in certain
circumstances and allows atomic operations on the data within. Using
this type, together with an Option, a Box and a Guard we can construct a
registry of all our ebpf programs and ensure every object is held by at
most one instance. Through the guard we can ensure that when that
instance fails and has to be recreated, the object is automatically
restored into the registry.

Structure:

1. Our registry is a struct of Arc pointers to be cloned where needed
   (We could also think about having that loaded as single global
   instance which would even more simplify the design)
2. Each Arc pointer contains an AtomicCell<Option<Box>>. We need to
   put T inside a box to ensure the Cell remains lock free. Option is a
   null pointer optimized type so this can be wrapped around regardless.
3. We pass that registry or a part therof to one of our instances, like
   the VfsWriteCollector. This collector can then atomically swap the
   value inside the AtomicCell with None and has exclusive access to T.
4. To ensure that none of our registry objects is lost, we put a Guard
   around T. This guard has a reference on the
   Arc<AtomicCell<Option<Box>>> which is None in that case. On drop
   it stores its value into the registry again.

[der-whity]

LGTM

[fhilgers]

Ill fix the wow in another PR as it is not of importance right now.

[Mr-Kanister]

Closes #123