fix: batched mode never cleared a transform state's change flags

ClearForNextTick had one production call site, inside OnUpdateAuthoritativeState, which a registered
instance never reaches because the tick loop skips anything the batched delta check already handled.
So in batched mode the change flags were never reset: any axial group that changed once kept its
Has*Change bit for the life of the instance and was serialized on every state update from then on.

Measured at 200 instances over 60 ticks, half float position and a compressed quaternion, with scale
registered and never touched: 100% of entries carried HasScaleChange and paid 6 bytes for a scale that
had not moved since spawn. The per instance path, which does clear, costs the same with scale
registered or not.

This is the third defect of the same shape, so rather than a second copy of the block the clear is now
ClearStateForNextTick, called from OnUpdateAuthoritativeState and from PrepareBatchedDeltaEntry. The
per instance side is a pure extraction: same condition, same body, same order relative to the axis
check and the delta check.

Author: NoelStephensUnity

com.unity.netcode.gameobjects/CHANGELOG.md

@@ -29,6 +29,7 @@ Additional documentation and release notes are available at [Multiplayer Documen
 - Fixed issue where scenes additively loaded before a session started were tracked as loaded on the server but had no scene handle entries, which caused `NetworkSceneManager.UnloadScene` to log an error and leave the scene registered as loaded even though it unloaded on all peers. (#4146)
 - Issue where objects using `NetworkTransform.UseHalfFloatPrecision` appeared to jitter on non-authority instances while they were stationary or coming to rest, even though the authority was not moving them. (#4129)
 - Issue where re-enabling a `NetworkTransform` position axis that had drifted out of half float delta range while it was disabled would not teleport, because the per axis check assigned its result rather than accumulating it and an in-range axis discarded what an out-of-range one had found. (#4123)
+- Issue where `TransformSyncModes.Batched` never cleared a `NetworkTransform` state update's change flags between ticks, because the only thing that cleared them ran from the per instance tick path. Any axial group that changed once kept its change flag for the life of the instance and was serialized on every state update from then on, so a registered but never changing scale cost 6 bytes per update indefinitely. (#4123)
 - Issue where lerp smoothing was applied per frame instead of over time, which caused the `Lerp` and `SmoothDampening` interpolation types to smooth by different amounts at different frame rates. Results at 60fps are unchanged. (#4132)
 - Issue where setting a maximum interpolation time of 1.0 would stop a `NetworkTransform` from interpolating at all when using the `Lerp` or `SmoothDampening` interpolation types. (#4132)
 - Issue where `NetworkTransform` interpolated towards a point in time taken from the local clock rather than the server clock that state updates are stamped on, which starved the interpolator on clients and reduced interpolation to snapping between state updates. (#4135)

com.unity.netcode.gameobjects/Runtime/Components/NetworkTransform.cs

@@ -2179,9 +2179,10 @@ internal void PrepareInterpolationEntry(ref InterpolationEntry entry)
         /// </summary>
         internal void PrepareBatchedDeltaEntry(ref TransformDeltaEntry entry)
         {
-            // The per instance path runs this from OnUpdateAuthoritativeState, which a registered instance
-            // never reaches, so it runs here instead. Without it a batched instance silently skips the
-            // teleport that re-enabling an axis can require.
+            // Both of these run from OnUpdateAuthoritativeState on the per instance path, which a registered
+            // instance never reaches. Without the clear the change flags only accumulate, and without the
+            // axis check a batched instance silently skips the teleport that re-enabling an axis requires.
+            ClearStateForNextTick();
             AxisChangedDeltaPositionCheck();
 
             // The entry is what the job reads, and anything the main thread set between ticks (a Teleport or
@@ -3608,27 +3609,46 @@ private void AxisChangedDeltaPositionCheck()
             }
         }
 
+        /// <summary>
+        /// Clears the previous tick's change flags so the next delta check starts from a clean bitset.
+        /// </summary>
+        /// <remarks>
+        /// Skipped while an explicit set or a teleport is pending, since both carry state the next update
+        /// still has to send.<br /><br />
+        /// Both synchronization modes have to run this and neither can borrow the other's call: the per
+        /// instance path runs it from <see cref="OnUpdateAuthoritativeState"/>, which a registered instance
+        /// never reaches, and the batched path from <see cref="PrepareBatchedDeltaEntry"/>. Without it the
+        /// bitset only ever accumulates, so an axial group that changed once keeps its change flag for the
+        /// life of the instance and is serialized on every state update from then on.
+        /// </remarks>
+        private void ClearStateForNextTick()
+        {
+            if (m_LocalAuthoritativeNetworkState.ExplicitSet
+                || !m_LocalAuthoritativeNetworkState.FlagStates.IsDirty
+                || m_LocalAuthoritativeNetworkState.IsTeleportingNextFrame)
+            {
+                return;
+            }
+
+            m_LocalAuthoritativeNetworkState.FlagStates.ClearForNextTick();
+            if (TrackStateUpdateId)
+            {
+                m_LocalAuthoritativeNetworkState.FlagStates.TrackByStateId = true;
+                m_LocalAuthoritativeNetworkState.StateId++;
+            }
+            else
+            {
+                m_LocalAuthoritativeNetworkState.FlagStates.TrackByStateId = false;
+            }
+        }
+
         /// <summary>
         /// Called by authority to check for deltas and update non-authoritative instances
         /// if any are found.
         /// </summary>
         internal void OnUpdateAuthoritativeState(bool settingState = false)
         {
-            // If our replicated state is not dirty and our local authority state is dirty, clear it.
-            if (!m_LocalAuthoritativeNetworkState.ExplicitSet && m_LocalAuthoritativeNetworkState.FlagStates.IsDirty && !m_LocalAuthoritativeNetworkState.IsTeleportingNextFrame)
-            {
-                // Now clear our bitset and prepare for next network tick state update
-                m_LocalAuthoritativeNetworkState.FlagStates.ClearForNextTick();
-                if (TrackStateUpdateId)
-                {
-                    m_LocalAuthoritativeNetworkState.FlagStates.TrackByStateId = true;
-                    m_LocalAuthoritativeNetworkState.StateId++;
-                }
-                else
-                {
-                    m_LocalAuthoritativeNetworkState.FlagStates.TrackByStateId = false;
-                }
-            }
+            ClearStateForNextTick();
 
             AxisChangedDeltaPositionCheck();