This change updates the project structure to become flattened.
Previously, the simulator, frontend and API each lived into their own
directory.

With this change, all modules of the project live in the top-level
directory of the repository. This should improve discoverability of
modules of the project.

This change migrates the remainder of the codebase to the
SimulationCoroutineDispatcher implementation.

This change introduces the SimulationCoroutineDispatcher implementation
which replaces the TestCoroutineDispatcher for running single-threaded
simulations.

Previously, we used the TestCoroutineDispatcher from the
kotlinx-coroutines-test modules for running simulations. However, this
module is aimed at coroutine tests and not at simulations.

In particular, having to construct a Clock object each time for the
TestCoroutineDispatcher caused a lot of unnecessary lines. With the new
approach, the SimulationCoroutineDispatcher automatically exposes a
usable Clock object.

In addition to ergonomic benefits, the SimulationCoroutineDispatcher is
much faster than the TestCoroutineDispatcher due to the assumption that
simulations run in only a single thread. As a result, the dispatcher
does not need to perform synchronization and can use the fast
PriorityQueue implementation.

This change removes the StateFlow speed property on the
SimResourceSource, as the overhead of emitting changes to the StateFlow
is too high in a single-thread context. Our new approach is to use
direct callbacks and counters.

This change updates the compute service simulator to use OpenTelemetry
for reporting metrics of the (simulated) hosts as opposed to using
custom event flows.

This approach is more generic, flexible and possibly offers better
performance as we can collect metrics of all services in a single sweep,
as opposed to listening to several services and each invoking the
handlers.

This change updates the resource model implementation to cache the
remaining work field, which was being computed multiple times during the
same cycle.

This change adds support for transforming the resource commands emitted
by the resource consumers. The SimResourceForwarder is modified to also
support transforming the resource commands.

This change re-enables support for VM usage metrics by adding an adapter
for SimResourceConsumer instances that can export the consumer speed.

This change adds support for dynamically changing the capacity of
resources and propagating this change to consumers.

This change removes the generic resource constraint (e.g., SimResource)
and replaces it by a simple capacity property. In the future, users
should handle the resource properties on a higher level.

This change simplifies compositions of consumers and providers by not
requiring a translation from resource to capacity.