fix(core): Core cleanup, adds event loop synchronization, and fixes gumps (#429)

- [X] Cleans up gump packets
- [X] Adds event loop task synchronization
- [X] Moves timer pause and cleans up the delay task timer class
- [X] Cleans up the conserve cpu
- [X] Renames variables to make them consistent with the new style
- [X] Removes process delta recursion checking.
- [X] Properly diposes net states. This fixes edge cases that may cause hanging connections to stay open longer than they should.
- [X] Fixes an issue with gump items not compiling properly

Users can now utilize `Timer.Pause()` since the code will be executed on the proper thread.

```cs
public void async void Talk()
{
    _canTalk = false;
    await Timer.Pause(Utility.RandomMinMax(5000, 8000)); // Talk after 5-8 seconds
    DoTalk();
    await Timer.Pause(Utility.RandomMinMax(12000, 25000)); // Reset ability to talk after 12-25 seconds
    _canTalk = true;
}
```

Projects/Server/EventLoopTasks.cs

@@ -0,0 +1,78 @@
+/*************************************************************************
+ * ModernUO                                                              *
+ * Copyright (C) 2019-2021 - ModernUO Development Team                   *
+ * Email: hi@modernuo.com                                                *
+ * File: EventLoopTasks.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.Concurrent;
+using System.Threading;
+
+namespace Server
+{
+    public sealed class EventLoopContext : SynchronizationContext
+    {
+        private readonly ConcurrentQueue<Action> _queue;
+        private readonly Thread _mainThread;
+
+        public EventLoopContext()
+        {
+            _queue = new ConcurrentQueue<Action>();
+            _mainThread = Thread.CurrentThread;
+        }
+
+        public override SynchronizationContext CreateCopy() => new EventLoopContext();
+
+        public override void Post(SendOrPostCallback d, object state) => _queue.Enqueue(() => d(state));
+
+        public override void Send(SendOrPostCallback d, object state)
+        {
+            if (Thread.CurrentThread == _mainThread)
+            {
+                d(state);
+                return;
+            }
+
+            AutoResetEvent evt = new AutoResetEvent(false);
+
+            _queue.Enqueue(() =>
+            {
+                d(state);
+                evt.Set();
+            });
+
+            evt.WaitOne();
+        }
+
+        public int ExecuteTasks()
+        {
+            if (Thread.CurrentThread != _mainThread)
+            {
+                throw new Exception("Called EventLoop.ExecuteTasks on incorrect thread!");
+            }
+
+            var count = _queue.Count;
+
+            for (int i = 0; i < count; i++)
+            {
+                if (!_queue.TryDequeue(out var a))
+                {
+                    return count;
+                }
+
+                a();
+            }
+
+            return count;
+        }
+    }
+}