This is a ring buffer storing the failure states of previously received
(and dropped) packet. The buffer will always overwrite the oldest errors
when it is full. An empty buffer, for example Default constructed, will
simply drop all errors. The buffer will keep a count of the number of
ignored errors.

Overall, this makes it possible to indicate more than one failure
condition per call to the library user. This is necessary to not
terminate a `poll` call immediately on the first error. Stored errors
can later be retrieved and inspected outside and independently of the
call that created them.

An instance of the buffer is added to the udp socket but largely unused
at the moment.

Augments `ErrorBuffer` with a callback based consumer for all pending
errors.

Here is why a buffer for errors is needed: The `poll` method of the
ethernet interface may potentially produce more than one signalling
error. But breaking out of control flow leaves the user without a proper
continuation option. A renewed call to `poll` would instead start
iterating sockets and packet flow in the previous order again, giving
unfair advantage to the flows called first. Specifically, the inbound
flow may also be controlled by a malicious party and error during
parsing and reception must not affect other flows.

Instead, we will try to store these errors inside a buffer provided in
the builder so that the programmer can control the number of errors they
want to inspect. Overflowing errors are dropped entirely.

This is part of a patch series introducing that error handling to all
socket types.

Adds methods for interacting with an ErrorBuffer similar to the methods
provided on Result itself. But instead of panicking or ignoring an Err
variant the contained error is pushed into the buffer.

Parsing incoming packets should not affect control flow for all other
packet flows that are to be handled, to guarantee that such packets can
not influence throughput adversely. This change will instead push them
into the error buffers of the ethernet interface or udp socket,
depending on how far parsing succeeded.

This is part of a patch series to harden packet handling against
adverserial network conditions and an overloaded network stack. Other
commits change the handling for the other socket and protocol types.

Where tests previously asserted that `process` completed without an
error they will no call process and assert that no error has been
created in the error buffer afterwards. The check does not depend on an
error buffer with non-zero capacity. But when the check has previously
checked for an error case, add an actual error buffer with capacity for
a single element and assert the same condition on the result of `pop`.
Since tests are short enough, the result of these operations can not
wrongly report the error condition of a previous packet processing.