test: Drop two NetworkDeltaPosition tests that cover an already covered path

ADeltaUnderTheThresholdIsLeftAsADelta asserted nothing the other tests do
not: MovingFoldsThePreviousRoundingLossBackIn already requires the delta
to stay under the threshold, and UnsynchronizedAxesAreLeftUntouched
already requires the synchronized axis to hold the movement.

QuantumDropsTheSignBecauseTheLatticeIsSymmetric ran its own value list to
assert one thing, so it moves into the loop in
QuantumIsTheSmallestChangeTheEncodingCanSee, which already walks the same
kind of values. 300f joins that list so no input is lost.

The masking it covers is a common path executed by every call, so the
coverage score is unchanged either way.

Author: NoelStephensUnity

com.unity.netcode.gameobjects/Tests/Runtime/NetworkTransform/NetworkDeltaPositionTests.cs

@@ -160,20 +160,6 @@ public void DeltaCollapsesIntoTheBaseAtTheThreshold()
                 "Folding the delta into the base must not move the object it describes.");
         }
 
-        [Test]
-        public void ADeltaUnderTheThresholdIsLeftAsADelta()
-        {
-            var deltaPosition = new NetworkDeltaPosition(k_Base, k_Tick);
-            var originalBase = deltaPosition.GetCurrentBasePosition();
-
-            var moved = Offset(k_LossyStep);
-            deltaPosition.UpdateFrom(ref moved, k_Tick + 1);
-
-            Assert.IsFalse(deltaPosition.CollapsedDeltaIntoBase, "A delta under the threshold should stay a delta.");
-            Assert.AreEqual(originalBase, deltaPosition.GetCurrentBasePosition(), "The base should not move while the delta is small.");
-            Assert.AreNotEqual(0.0f, deltaPosition.GetDeltaPosition().x, "The delta should hold the movement.");
-        }
-
         [Test]
         public void UnsynchronizedAxesAreLeftUntouched()
         {
@@ -305,7 +291,7 @@ public void FullPrecisionRoundTripsWhenTheBaseIsSynchronized()
         public void QuantumIsTheSmallestChangeTheEncodingCanSee()
         {
             // Exactly representable, so "one step away" is unambiguous.
-            foreach (var value in new[] { 0.5f, 1.0f, -1.0f, 2.0f, 1024.0f })
+            foreach (var value in new[] { 0.5f, 1.0f, -1.0f, 2.0f, 300.0f, 1024.0f })
             {
                 var quantum = NetworkDeltaPosition.HalfPrecisionQuantum(value);
                 Assert.Greater(quantum, 0.0f, $"The step size at {value} should be positive.");
@@ -314,16 +300,9 @@ public void QuantumIsTheSmallestChangeTheEncodingCanSee()
                     $"A full step from {value} should encode differently, or it is not the step size.");
                 Assert.AreEqual(math.half(value).value, math.half(value + (quantum * 0.25f)).value,
                     $"A quarter step from {value} should encode identically, or the step size is too large.");
-            }
-        }
 
-        [Test]
-        public void QuantumDropsTheSignBecauseTheLatticeIsSymmetric()
-        {
-            foreach (var value in new[] { 0.5f, 1.0f, 300.0f, 1024.0f })
-            {
-                Assert.AreEqual(NetworkDeltaPosition.HalfPrecisionQuantum(value),
-                    NetworkDeltaPosition.HalfPrecisionQuantum(-value),
+                // The lattice is symmetric about zero, which is why the sign is dropped.
+                Assert.AreEqual(quantum, NetworkDeltaPosition.HalfPrecisionQuantum(-value),
                     $"The step size at {value} and {-value} should be the same.");
             }
         }