The intent of this commit is to remove the quantity of log that is being pushed to user.

This commit removes the redeclaration of a set up tracing methods to centralise
the tokio-tracing subscriber within the extension crate. It also add the
feature to filter information based on Environment variable.
This makes it possible to define the log level for tokio tracing like
this:
```
RUST_LOG=debug dora-daemon --run-dataflow dataflow.yml
```

I have also unified the feature flag to make it easier to manage tracing features among the workspace.

I did not change the default behaviour of tracing in our crates and therefore by
using the command above you should get the same tracing log as before.

fix merge conflict generated

Allows queueing of multiple messages on the TCP socket, which considerably improves throughput.

Sends a list of all queued events in the reply instead of sending them one-by-one. This way, we avoid some communication overhead.

We currently need an additional request to prepare zero-copy shared memory messages. For small messages, it might be faster to avoid this extra round-trip and send the message directly over TCP. This commit implements support for this. Messages smaller than a threshold (currently set to 4096 bytes) are sent via TCP, while larger messages still use shared memory.

This step also enables future optimizations such as queueing output messages in order to improve the throughput.

These two messages can be essential for correctness. For example, a node might not finish properly when an `InputClosed` event is lost. So we need to always send them, even if the target node was not subscribed yet when the event occurred.

- don't fail daemon when a node errors
- detects when a node exited because of a signal
- improve log messages

We cannot wait until all operators of the runtime node are finished because operators might be subscribed to other operators.

We don't want to drop other types of events (e.g. stop or input closed) because they might be important for the correct functionality. For this reason, we only drop input events now. To implement this, we use a FIFO buffer in the listener instead of dropping the events on the sender side.

This commit also fixes a memory leak that occured when dropping values. We now report the drop tokens properly to the shared memory handler when dropping an input.

Drop oldest message when queue is full.

This reverts commit accfae6d97.

To allow for individual testing and benchmarking. This will also enable reuse of the library in other projects.

To reduce load on the main task.