Ensures orderly shutdown for a set of LifeCycleManager.ManagedResources and dependent LifeCycleManagers. This creates a shutdown hierarchy.

When a LifeCycleManager is closed with LifeCycleManager.closeAsync, the following shutdown procedure is applied:

1. Close signal propagation: The LifeCycleManager and all its dependent LifeCycleManagers are notified that closing is in progress. Thereafter, their HasRunOnClosing.isClosing returns true. Transitive dependents are also notified, but this need not be synchronized with the next step.
2. Run on closing: The RunOnClosing tasks registered with the LifeCycleManager. Exceptions from the RunOnClosing tasks are logged and then discarded. The dependent LifeCycleManagers also start running their RunOnClosing tasks.
3. Synchronize with closing: The LifeCycleManager waits until all its HasSynchronizeWithClosing.synchronizeWithClosing computations have finished or until LifeCycleManager.synchronizeWithClosingPatience has elapsed.
4. Release: The LifeCycleManager releases all its LifeCycleManager.ManagedResources and instructs dependent LifeCycleManagers to do so in ascending priority order. Within the same priority, releasing is unordered and possibly in parallel. When a dependent LifeCycleManager is instructed, it waits until step 2 has finished and then performs steps 3 and 4 of this procedure.

Exceptions thrown in the last step "release" are propagated as a ShutdownFailedException with proper exception chaining. If the third step completes because the patience has elapsed and some HasSynchronizeWithClosing.synchronizeWithClosing computations are still running at the end of the last step, a ShutdownFailedException signals such a synchronization failure.

Rationale for this exception handling policy:

• When an exception happens in the last step, it is unknown whether all dependencies have successfully finished all their business. So we must signal to the caller that the unexpected happened.
• When some HasSynchronizeWithClosing.synchronizeWithClosing is still running after everything has been released, we cannot guarantee that all side effects guarded by this shutdown hierarchy are over. We signal this to the caller via an exception.
• In contrast, RunOnClosing tasks are meant to quickly clean up stuff upon closing. They are not synchronized with closing, and therefore we merely log exceptions, but do not propagate them.