Replace DependencyInjectionException with rethrown exceptions

osu.Framework/Allocation/BackgroundDependencyLoaderAttribute.cs

···
                         }
                         catch (TargetInvocationException exc) // During non-await invocations
                         {
-                            switch (exc.InnerException)
-                            {
-                                case OperationCanceledException _:
-                                    // This activator is cancelled - propagate the cancellation as-is (it will be handled silently)
-                                    throw exc.InnerException;
-
-                                case DependencyInjectionException die:
-                                    // A nested activator has failed (multiple Invoke() calls) - propagate the original error
-                                    throw die;
-                            }
-
-                            // This activator has failed (single reflection call) - preserve the original stacktrace while notifying of the error
-                            throw new DependencyInjectionException { DispatchInfo = ExceptionDispatchInfo.Capture(exc.InnerException) };
+                            ExceptionDispatchInfo.Capture(exc.InnerException).Throw();
                         }
                     };
 

osu.Framework/Allocation/DependencyActivator.cs

···
 using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Reflection;
-using System.Runtime.ExceptionServices;
 using osu.Framework.Extensions.TypeExtensions;
-using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 
 namespace osu.Framework.Allocation
···
             : base(modifier, member, $"A property with an attached {nameof(ResolvedAttribute)} must have a private setter.")
         {
         }
-    }
-
-    /// <summary>
-    /// Occurs when dependencies dependency injection into a <see cref="Drawable"/> fails.
-    /// </summary>
-    internal class DependencyInjectionException : Exception
-    {
-        public ExceptionDispatchInfo DispatchInfo;
     }
 
     internal delegate void InjectDependencyDelegate(object target, IReadOnlyDependencyContainer dependencies);

osu.Framework/Allocation/DependencyContainer.cs

···
         /// </summary>
         /// <typeparam name="T">The type of the instance to inject dependencies into.</typeparam>
         /// <param name="instance">The instance to inject dependencies into.</param>
-        /// <exception cref="DependencyInjectionException">When any user error has occurred.
-        /// Rethrow <see cref="DependencyInjectionException.DispatchInfo"/> when appropriate to retrieve the original exception.</exception>
         /// <exception cref="OperationCanceledException">When the injection process was cancelled.</exception>
         public void Inject<T>(T instance)
             where T : class

osu.Framework/Graphics/Containers/CompositeDrawable.cs

···
         /// Loads a <see cref="Drawable"/> child. This will not throw in the event of the load being cancelled.
         /// </summary>
         /// <param name="child">The <see cref="Drawable"/> child to load.</param>
-        /// <exception cref="DependencyInjectionException">When a user error occurred during dependency injection.</exception>
         private void loadChild(Drawable child)
         {
             try

osu.Framework/Platform/GameHost.cs

···
             // Ensure we maintain a valid size for any children immediately scaling by the window size
             Root.Size = Vector2.ComponentMax(Vector2.One, Root.Size);
 
-            try
-            {
-                Root.UpdateSubTree();
-            }
-            catch (DependencyInjectionException die)
-            {
-                die.DispatchInfo.Throw();
-            }
-
+            Root.UpdateSubTree();
             Root.UpdateSubTreeMasking(Root, Root.ScreenSpaceDrawQuad.AABBFloat);
 
             using (var buffer = DrawRoots.Get(UsageType.Write))
···
 
             game.SetHost(this);
 
-            try
-            {
-                root.Load(SceneGraphClock, Dependencies);
-            }
-            catch (DependencyInjectionException die)
-            {
-                die.DispatchInfo.Throw();
-            }
+            root.Load(SceneGraphClock, Dependencies);
 
             //publish bootstrapped scene graph to all threads.
             Root = root;

osu.Framework/Testing/Drawables/Steps/StepButton.cs

···
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
-using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
···
             }
             catch (Exception exc)
             {
-                if (exc.InnerException is DependencyInjectionException die)
-                    exc = die.DispatchInfo.SourceException;
                 Logging.Logger.Error(exc, $"Step {this} triggered an error");
             }
 

osu.Framework/Testing/TestSceneTestRunner.cs

···
                         Scheduler.AddDelayed(complete, time_between_tests);
                     }, e =>
                     {
-                        if (e is DependencyInjectionException die)
-                            exception = die.DispatchInfo;
-                        else
-                            exception = ExceptionDispatchInfo.Capture(e);
+                        exception = ExceptionDispatchInfo.Capture(e);
                         complete();
                     });
                 });