Fix possible crash when scaling objects in editor

The specific fail case here is when `s.{X,Y}` is 0, and
`s{Lower,Upper}Bound` is `Infinity`. Because IEEE math is IEEE math,
`0 * Infinity` is `NaN`.

`MathHelper.Clamp()` is written the following way:

	https://github.com/ppy/osuTK/blob/af742f1afd01828efc7bc9fe77536b54aab8b419/src/osuTK/Math/MathHelper.cs#L284-L306

`Math.{Min,Max}` are both documented as reporting `NaN` when any of
their operands are `NaN`:

	https://learn.microsoft.com/en-us/dotnet/api/system.math.min?view=net-8.0#system-math-min(system-single-system-single)
	https://learn.microsoft.com/en-us/dotnet/api/system.math.max?view=net-8.0#system-math-max(system-single-system-single)

which means that if a `NaN` happens to sneak into the bounds, it will
start spreading outwards in an uncontrolled manner, and likely crash
things.

In contrast, the standard library provided `Math.Clamp()` is written
like so:

	https://github.com/dotnet/runtime/blob/577c36cee56480dec4d4610b35605b5d5836888b/src/libraries/System.Private.CoreLib/src/System/Math.cs#L711-L729

With this implementation, if either bound is `NaN`, it will essentially
not be checked (because any and all comparisons involving `NaN` return
false). This prevents the spread of `NaN`s, all the way to positions
of hitobjects, and thus fixes the crash.

Author: bdach

osu.Game.Rulesets.Osu/Edit/OsuSelectionScaleHandler.cs

@@ -263,24 +263,24 @@ Vector2 clampToBounds(Vector2 s, Vector2 p, Vector2 lowerBounds, Vector2 upperBo
                 {
                     case Axes.X:
                         (sLowerBound, sUpperBound) = computeBounds(lowerBounds - b, upperBounds - b, a);
-                        s.X = MathHelper.Clamp(s.X, sLowerBound, sUpperBound);
+                        s.X = Math.Clamp(s.X, sLowerBound, sUpperBound);
                         break;
 
                     case Axes.Y:
                         (sLowerBound, sUpperBound) = computeBounds(lowerBounds - a, upperBounds - a, b);
-                        s.Y = MathHelper.Clamp(s.Y, sLowerBound, sUpperBound);
+                        s.Y = Math.Clamp(s.Y, sLowerBound, sUpperBound);
                         break;
 
                     case Axes.Both:
                         // Here we compute the bounds for the magnitude multiplier of the scale vector
                         // Therefore the ratio s.X / s.Y will be maintained
                         (sLowerBound, sUpperBound) = computeBounds(lowerBounds, upperBounds, a * s.X + b * s.Y);
                         s.X = s.X < 0
-                            ? MathHelper.Clamp(s.X, s.X * sUpperBound, s.X * sLowerBound)
-                            : MathHelper.Clamp(s.X, s.X * sLowerBound, s.X * sUpperBound);
+                            ? Math.Clamp(s.X, s.X * sUpperBound, s.X * sLowerBound)
+                            : Math.Clamp(s.X, s.X * sLowerBound, s.X * sUpperBound);
                         s.Y = s.Y < 0
-                            ? MathHelper.Clamp(s.Y, s.Y * sUpperBound, s.Y * sLowerBound)
-                            : MathHelper.Clamp(s.Y, s.Y * sLowerBound, s.Y * sUpperBound);
+                            ? Math.Clamp(s.Y, s.Y * sUpperBound, s.Y * sLowerBound)
+                            : Math.Clamp(s.Y, s.Y * sLowerBound, s.Y * sUpperBound);
                         break;
                 }