feat: auto-configure NetcodeConfig for hybrid mode

When Netcode for Entities is installed and a registered network prefab
carries a GhostObject, the project's NetCodeConfig is now aligned with
what NGO needs rather than leaving it to the user to discover.

The two settings hybrid mode cannot run without (single world hosting,
and automatic bootstrapping disabled since NetworkManager owns world
creation) are corrected whenever they drift. The Netcode for Entities
tick rates are driven from NetworkConfig.TickRate so that ghost
transform updates land on the same interval as everything else. The
snapshot, interpolation and transport values tuned against the 2000
instance stress test are applied once and then left alone, so a user's
own edits survive; Project Settings > Multiplayer > Netcode for
GameObjects can restore them.

The config is never created here. Netcode for Entities already creates
one unconditionally from its own InitializeOnLoadMethod, and creating a
second lands the project in its multiple-config error path.

Also:
- UnifiedIsConfiguredCorrectly now validates EnableClientServerBootstrap
  and warns when the two tick rates diverge. Its two log messages were
  missing their string interpolation prefixes.
- m_TempStreamSize returns to the Netcode for Entities default of 8192.
  GhostSendSystem takes max(TempStreamInitialSize, dataStream.Capacity),
  and capacity is DefaultSnapshotPacketSize, so 4192 had no effect.
- Unity.Netcode.Editor.Tests gains the UNIFIED_NETCODE version define.
  Without it any hybrid editor test compiles away and reports zero cases
  rather than failing.
- Adds a measurement fixture for sizing DefaultSnapshotPacketSize. It is
  marked Explicit so its 24 cases stay out of the suites.

Author: NoelStephensUnity

com.unity.netcode.gameobjects/CHANGELOG.md

@@ -10,6 +10,8 @@ Additional documentation and release notes are available at [Multiplayer Documen
 
 ### Added
 
+- Added automatic `NetCodeConfig` configuration for hybrid mode. When Netcode for Entities is installed and a registered network prefab has a `GhostObject`, the settings hybrid mode requires are corrected automatically and the Netcode for Entities tick rates are driven from `NetworkConfig.TickRate`. The recommended snapshot, interpolation and transport values are applied once, and can be restored from Project Settings > Multiplayer > Netcode for GameObjects.
+
 
 ### Changed
 
@@ -32,6 +34,7 @@ Additional documentation and release notes are available at [Multiplayer Documen
 - Issue with not being able to spawn initially disabled in-scene placed objects. (#4093)
 - Issue with pre-instantiated network prefab instances being marked as in-scene placed. Now pre-instantiated network prefabs are dynamically spawned. (#4093)
 - Issue where a user could spawn runtime created `NetworkObject` that has a GlobalObjectIdHash of zero. These are not valid instances and will no longer be allowed to spawn. (#4093)
+- Issue where the hybrid mode `NetCodeConfig` validation messages were not interpolated and did not check that automatic bootstrapping was disabled.
 
 
 ### Security

com.unity.netcode.gameobjects/Editor/Configuration/HybridNetcodeConfigApplier.cs

@@ -0,0 +1,210 @@
+#if UNIFIED_NETCODE
+using Unity.NetCode;
+using UnityEditor;
+using UnityEngine;
+
+namespace Unity.Netcode.GameObjects.Editor.Configuration
+{
+    /// <summary>
+    /// Keeps the project's <see cref="NetCodeConfig"/> aligned with what NGO needs whenever the project is running in
+    /// hybrid mode (Netcode for Entities installed, and at least one registered network prefab carrying a ghost).
+    /// </summary>
+    /// <remarks>
+    /// This never creates a <see cref="NetCodeConfig"/>. Netcode for Entities already creates one unconditionally from
+    /// its own <see cref="InitializeOnLoadMethodAttribute"/>, and creating a second lands the project in N4E's
+    /// multiple-config error path. We find the one N4E settled on and correct it.
+    /// </remarks>
+    internal static class HybridNetcodeConfigApplier
+    {
+        [InitializeOnLoadMethod]
+        private static void OnApplicationStart()
+        {
+            // N4E creates and assigns the global config from its own InitializeOnLoadMethod. Cross-assembly ordering
+            // between the two is not a documented contract, so defer rather than racing it.
+            EditorApplication.delayCall += OnDelayCall;
+        }
+
+        private static void OnDelayCall()
+        {
+            EditorApplication.delayCall -= OnDelayCall;
+            Apply(false);
+        }
+
+        /// <summary>
+        /// Corrects the global <see cref="NetCodeConfig"/> for hybrid mode, if this is a hybrid project.
+        /// </summary>
+        /// <param name="applyRecommended">
+        /// When true, re-applies the full tuned set even if this project has already had it applied once. Driven by the
+        /// button in Project Settings. When false, the tuned values are only written the first time, so that a user's
+        /// own edits are not repeatedly overwritten.
+        /// </param>
+        internal static void Apply(bool applyRecommended)
+        {
+            if (EditorApplication.isPlayingOrWillChangePlaymode)
+            {
+                return;
+            }
+
+            var config = ResolveGlobalConfig();
+            if (config == null || !IsHybridProject())
+            {
+                return;
+            }
+
+            var settings = NetcodeForGameObjectsProjectSettings.instance;
+            var isFirstApply = settings.HybridDefaultsVersion < HybridNetcodeDefaults.Version;
+            var changed = false;
+
+            if (applyRecommended || isFirstApply)
+            {
+                changed = HybridNetcodeDefaults.ApplyRecommended(config, ResolveTickRate(config));
+                if (changed)
+                {
+                    Debug.Log($"[Netcode] Applied the NGO hybrid mode defaults to '{config.name}'. These are tuned for NGO and can be changed freely; they will not be re-applied automatically. Use Project Settings > Multiplayer > Netcode for GameObjects to restore them.", config);
+                }
+            }
+            else
+            {
+                // Outside the one-shot, only the settings hybrid mode cannot run without are enforced, plus the tick
+                // rate, which NGO owns.
+                changed = HybridNetcodeDefaults.ApplyRequired(config);
+                if (changed)
+                {
+                    Debug.LogWarning($"[Netcode] Corrected required hybrid mode settings on '{config.name}'. Netcode for GameObjects owns world creation and requires single world hosting, so these two cannot be changed while ghost prefabs are registered.", config);
+                }
+
+                changed |= HybridNetcodeDefaults.ApplyTickRate(config, ResolveTickRate(config));
+            }
+
+            if (!changed)
+            {
+                return;
+            }
+
+            settings.HybridDefaultsVersion = HybridNetcodeDefaults.Version;
+            settings.SaveSettings();
+
+            EditorUtility.SetDirty(config);
+            AssetDatabase.SaveAssetIfDirty(config);
+        }
+
+        /// <summary>
+        /// True when any <see cref="NetworkManager"/> in the project has a registered prefab carrying a ghost.
+        /// </summary>
+        /// <returns>Whether this project is configured for hybrid mode.</returns>
+        internal static bool IsHybridProject()
+        {
+            foreach (var networkManager in Resources.FindObjectsOfTypeAll<NetworkManager>())
+            {
+                var prefabs = networkManager.NetworkConfig?.Prefabs;
+                if (prefabs == null)
+                {
+                    continue;
+                }
+
+                foreach (var prefab in prefabs.Prefabs)
+                {
+                    if (HasGhost(prefab))
+                    {
+                        return true;
+                    }
+                }
+
+                foreach (var prefabsList in prefabs.NetworkPrefabsLists)
+                {
+                    if (prefabsList == null)
+                    {
+                        continue;
+                    }
+
+                    foreach (var prefab in prefabsList.PrefabList)
+                    {
+                        if (HasGhost(prefab))
+                        {
+                            return true;
+                        }
+                    }
+                }
+            }
+
+            return false;
+        }
+
+        private static bool HasGhost(NetworkPrefab prefab)
+        {
+            return prefab?.Prefab != null
+                && prefab.Prefab.TryGetComponent<NetworkObject>(out var networkObject)
+                && networkObject.HasGhost;
+        }
+
+        /// <summary>
+        /// Resolves the config N4E considers global, falling back to a project scan when N4E has not assigned one yet.
+        /// </summary>
+        /// <returns>The config to correct, or null when none exists yet.</returns>
+        internal static NetCodeConfig ResolveGlobalConfig()
+        {
+            if (NetCodeConfig.Global != null)
+            {
+                return NetCodeConfig.Global;
+            }
+
+            var guids = AssetDatabase.FindAssets($"t:{nameof(NetCodeConfig)}");
+            return guids.Length == 1 ? AssetDatabase.LoadAssetAtPath<NetCodeConfig>(AssetDatabase.GUIDToAssetPath(guids[0])) : null;
+        }
+
+        /// <summary>
+        /// The tick rate N4E should be driven at. NGO owns this, so it comes from <see cref="NetworkConfig.TickRate"/>.
+        /// </summary>
+        /// <param name="config">The config, used as the fallback when no NetworkManager can be found.</param>
+        /// <returns>The tick rate to write into the config.</returns>
+        private static uint ResolveTickRate(NetCodeConfig config)
+        {
+            var found = 0u;
+            var diverged = false;
+            foreach (var networkManager in Resources.FindObjectsOfTypeAll<NetworkManager>())
+            {
+                var tickRate = networkManager.NetworkConfig?.TickRate ?? 0u;
+                if (tickRate == 0)
+                {
+                    continue;
+                }
+
+                diverged |= found != 0 && found != tickRate;
+                found = tickRate;
+            }
+
+            if (diverged)
+            {
+                Debug.LogWarning($"[Netcode] Found {nameof(NetworkManager)}s with differing {nameof(NetworkConfig.TickRate)} values. '{config.name}' has been set to {found}; hybrid mode expects a single tick rate across the project.", config);
+            }
+
+            // No NetworkManager to read from (a prefab-only project, or one mid-import) leaves the config as it is.
+            return found != 0 ? found : (uint)config.ClientServerTickRate.SimulationTickRate;
+        }
+    }
+
+    /// <summary>
+    /// Re-runs the hybrid config pass when a prefab import could have turned this into a hybrid project.
+    /// </summary>
+    internal class HybridNetcodeConfigPostprocessor : AssetPostprocessor
+    {
+        private static void OnPostprocessAllAssets(string[] importedAssets, string[] deletedAssets, string[] movedAssets, string[] movedFromAssetPaths)
+        {
+            foreach (var assetPath in importedAssets)
+            {
+                if (AssetDatabase.GetMainAssetTypeAtPath(assetPath) != typeof(GameObject))
+                {
+                    continue;
+                }
+
+                var gameObject = AssetDatabase.LoadAssetAtPath<GameObject>(assetPath);
+                if (gameObject != null && gameObject.TryGetComponent<NetworkObject>(out var networkObject) && networkObject.HasGhost)
+                {
+                    HybridNetcodeConfigApplier.Apply(false);
+                    return;
+                }
+            }
+        }
+    }
+}
+#endif

com.unity.netcode.gameobjects/Editor/Configuration/HybridNetcodeConfigApplier.cs.meta

@@ -35,6 +35,18 @@ private void OnEnable()
         [SerializeField]
         public bool GenerateDefaultNetworkPrefabs = true;
 
+#if UNIFIED_NETCODE
+        /// <summary>
+        /// The version of the NGO hybrid mode defaults already applied to this project's NetCodeConfig.
+        /// </summary>
+        /// <remarks>
+        /// Zero means they have never been applied. Recording it is what keeps the tuned values a one-shot, so that a
+        /// user who deliberately changes them does not have them overwritten on the next domain reload.
+        /// </remarks>
+        [SerializeField]
+        public int HybridDefaultsVersion;
+#endif
+
         internal void SaveSettings()
         {
             Save(true);

com.unity.netcode.gameobjects/Editor/Configuration/NetcodeForGameObjectsProjectSettings.cs

@@ -1,5 +1,8 @@
 using System.Collections.Generic;
 using System.IO;
+#if UNIFIED_NETCODE
+using Unity.NetCode;
+#endif
 using UnityEditor;
 using UnityEngine;
 using Directory = UnityEngine.Windows.Directory;
@@ -192,6 +195,10 @@ private static void OnGuiHandler(string obj)
                     networkPrefabsPath,
                     GUILayout.Width(s_MaxLabelWidth + 270));
                 GUILayout.EndVertical();
+
+#if UNIFIED_NETCODE
+                DrawHybridSettings(settings);
+#endif
             }
             EditorGUILayout.EndFoldoutHeaderGroup();
             GUILayout.EndVertical();
@@ -205,6 +212,48 @@ private static void OnGuiHandler(string obj)
                 settings.SaveSettings();
             }
         }
+
+#if UNIFIED_NETCODE
+        /// <summary>
+        /// Surfaces the state of the project's NetCodeConfig, and offers a way back to the NGO defaults for anyone who
+        /// has since changed them.
+        /// </summary>
+        /// <param name="settings">The project settings holding the applied-defaults marker.</param>
+        private static void DrawHybridSettings(NetcodeForGameObjectsProjectSettings settings)
+        {
+            GUILayout.BeginVertical("Box");
+            GUILayout.Label("Hybrid (Netcode for Entities)", EditorStyles.boldLabel);
+
+            if (!HybridNetcodeConfigApplier.IsHybridProject())
+            {
+                EditorGUILayout.HelpBox("No registered network prefab has a GhostObject, so this project is not using hybrid mode. Netcode for GameObjects leaves the NetCodeConfig alone until one does.", MessageType.Info);
+                GUILayout.EndVertical();
+                return;
+            }
+
+            var config = HybridNetcodeConfigApplier.ResolveGlobalConfig();
+            if (config == null)
+            {
+                EditorGUILayout.HelpBox("No NetCodeConfig could be resolved. Open Project Settings > Multiplayer, which creates one, then return here.", MessageType.Warning);
+                GUILayout.EndVertical();
+                return;
+            }
+
+            EditorGUILayout.ObjectField(new GUIContent("Applied to", "The NetCodeConfig that Netcode for GameObjects keeps aligned for hybrid mode."), config, typeof(NetCodeConfig), false);
+
+            if (settings.HybridDefaultsVersion < HybridNetcodeDefaults.Version)
+            {
+                EditorGUILayout.HelpBox("The Netcode for GameObjects hybrid defaults have not been applied to this config yet.", MessageType.Info);
+            }
+
+            if (GUILayout.Button(new GUIContent("Apply Recommended Hybrid Defaults", "Restores the snapshot, interpolation and transport values Netcode for GameObjects recommends for hybrid mode, and re-syncs the tick rate from your NetworkManager. Applied automatically once; use this to get back to them after changing them.")))
+            {
+                HybridNetcodeConfigApplier.Apply(true);
+            }
+
+            GUILayout.EndVertical();
+        }
+#endif
     }
 
     internal class NetcodeSettingsLabel : NetcodeGUISettings