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 changes the TimerScheduler implementation to prevent calling
Intrinsics.areEqual in the hot path. Profiling shows that especially
this call has a high overhead.

This change updates the TimerScheduler implementation to cache several
variables in the hot paths of the implementation.

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 re-designs the SimResourceConsumer interface to support in
the future capacity negotiation. This basically means that the consumer
will be informed directly when not enough capacity is available, instead
of after the deadline specified by the consumer.

This change moves the hypervisor implementations to the
opendc-simulator-resources module and makes them generic to the resource
type that is being used (e.g., CPU, disk or networking).

This change fixes a possible memory leakage issue in TimerScheduler when
a large number of timers was scheduled for the same timestamp.

This change adds a generic framework for modeling resource consumptions and
adapts opendc-simulator-compute to model machines and VMs on top of
this framework.

This framework anticipates the addition of additional resource types
such as memory, disk and network to the OpenDC codebase.