Configure module dependencies, manage module lifecycles, and set up
the unified application log for inter-module communication.

Implementation of the interceptor pattern based on an asynchronous promise
chain.

Interceptors map hook functions to the three execution stages `:enter`,
`:leave`, and `:error`. All hook functions are optional, will be passed
the current execution context, and need to return an updated context.

When executing a context, first each `:enter` hook is triggered in order.
After that, each intereptor's `:leave` hook will be invoked in reverse order.
At any point, when an error occurs the execution of remaining interceptors is
terminated and the `:error` function of previously processed interceptors is
triggered in reverse order.

The `::queue` of pending interceptors and `::stack` of partially processed
inteceptors are always present on the context. It is perfectly valid for
interceptor hooks to alter those in order to change execution.

The current error is available via `::error`. To catch an error return a
context with the key removed. To signal an error return a context with the
`::error` key present.