feat: Adds an Item/Mobile memory leak detector. Fixes minor leak in doors. (#2159)

### Summary

Adds the command [TrackLeaks to enable tracking item/mobiles that have been deleted but still have dangling references. Requires adding the _TRACK_LEAKS_ define constant during build.

Projects/Server/EntityFinalizationTracker.cs

@@ -0,0 +1,177 @@
+/*************************************************************************
+ * ModernUO                                                              *
+ * Copyright 2019-2025 - ModernUO Development Team                       *
+ * Email: hi@modernuo.com                                                *
+ * File: EntityFinalizationTracker.cs                                    *
+ *                                                                       *
+ * This program is free software: you can redistribute it and/or modify  *
+ * it under the terms of the GNU General Public License as published by  *
+ * the Free Software Foundation, either version 3 of the License, or     *
+ * (at your option) any later version.                                   *
+ *                                                                       *
+ * You should have received a copy of the GNU General Public License     *
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>. *
+ *************************************************************************/
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.CompilerServices;
+using System.Threading;
+using Server.Logging;
+
+namespace Server;
+
+public static class EntityFinalizationTracker
+{
+    private static readonly ILogger logger = LogFactory.GetLogger(typeof(EntityFinalizationTracker));
+
+    private sealed record TrackedEntity(WeakReference<IEntity> Reference, int ReferenceHash, DateTime RemovedAt);
+
+    private static readonly Lock _sync = new();
+    private static bool _enabled;
+    private static DateTime _nextCheck = DateTime.MinValue;
+
+#if TRACK_LEAKS
+    private const bool CanBeEnabled = true;
+#else
+    private const bool CanBeEnabled = false;
+#endif
+
+    public static void Configure()
+    {
+        CommandSystem.Register("gc", AccessLevel.Administrator, _ => GC.Collect(GC.MaxGeneration, GCCollectionMode.Forced, blocking: true, compacting: true));
+        CommandSystem.Register("TrackLeaks", AccessLevel.Developer, TrackLeaks_OnCommand);
+    }
+
+    [Usage("TrackLeaks <on|off>")]
+    [Description("Enables or disables entity leak tracking. May impact performance and should be used only when necessary!")]
+    private static void TrackLeaks_OnCommand(CommandEventArgs e)
+    {
+        var from = e.Mobile;
+        if (!CanBeEnabled) {
+            from.SendMessage("Entity leak tracking is not enabled in this build. Rebuild with TRACK_LEAKS defined.");
+            return;
+        }
+
+        if (e.Arguments.Length == 0)
+        {
+            from.SendMessage("Usage: TrackLeaks <on|off>");
+            return;
+        }
+
+        var enable = Utility.ToBoolean(e.Arguments[0]);
+        var status = enable ? "enabled" : "disabled";
+        if (enable == _enabled)
+        {
+            from.SendMessage($"Entity leak tracking already {status}.");
+            return;
+        }
+
+        if (_enabled)
+        {
+            EnableLeakTracking(from);
+        }
+        else
+        {
+            DisableLeakTracking(from);
+        }
+    }
+
+    private static void EnableLeakTracking(Mobile from)
+    {
+        if (_enabled)
+        {
+            return;
+        }
+
+        _enabled = true;
+        Gen2GcCallback.Register(() =>
+        {
+            CheckLeaks();
+            return _enabled;
+        });
+
+        from.SendMessage("Entity leak tracking enabled.");
+        logger.Warning("Entity leak tracking enabled by {Name} ({Serial:X8})", from.Name, from.Serial);
+    }
+
+    private static void DisableLeakTracking(Mobile from)
+    {
+        if (!_enabled)
+        {
+            return;
+        }
+
+        _enabled = false;
+        from.SendMessage("Entity leak tracking disabled.");
+        logger.Warning("Entity leak tracking disabled by {Name} ({Serial:X8})", from.Name, from.Serial);
+    }
+
+    private static readonly List<TrackedEntity> _entities = [];
+    private static readonly HashSet<int> _finalizedHashes = [];
+
+    public static void TrackEntity<T>(T entity) where T : IEntity
+    {
+        lock (_sync)
+        {
+            var hash = RuntimeHelpers.GetHashCode(entity);
+            _entities.Add(new TrackedEntity(new WeakReference<IEntity>(entity), hash, Core.Now));
+        }
+    }
+
+    public static void NotifyFinalized(object entity)
+    {
+        lock (_sync)
+        {
+            _finalizedHashes.Add(RuntimeHelpers.GetHashCode(entity));
+        }
+    }
+
+    private static void CheckLeaks()
+    {
+        if (_entities.Count == 0)
+        {
+            return;
+        }
+
+        var now = Core.Now;
+        if (now <= _nextCheck)
+        {
+            return;
+        }
+
+        _nextCheck = now + TimeSpan.FromMinutes(2);
+
+        _entities.RemoveAll(entry =>
+        {
+            if (_finalizedHashes.Remove(entry.ReferenceHash))
+            {
+                return true;
+            }
+
+            if (!entry.Reference.TryGetTarget(out var obj) || obj is not IEntity entity)
+            {
+                return true;
+            }
+
+            if (ExceptionToLeakCheck(entity))
+            {
+                return false;
+            }
+
+            var duration = now - entry.RemovedAt;
+
+            if (duration <= TimeSpan.FromSeconds(120))
+            {
+                return false;
+            }
+
+            logger.Warning("[Leak Warning] {Name} ({Serial:X8}) collected but not finalized after {Duration}.", entity.GetType().Name, entity.Serial, duration);
+            return false;
+        });
+    }
+
+    private static bool ExceptionToLeakCheck(IEntity entity) =>
+        // Mobiles that are deleted, but have a reference to a corpse that is not deleted should be exempt
+        (entity as Mobile)?.Corpse?.Deleted == false;
+}