[Milestone] AssemblyLoader completed.

Details:
- Assembly Mgmt Service for loading now a separate interface, not intended for normal use.
- Assembly Loader work; implemented custom dictionary key and table.
- Assembly loading work.
- EventService completed.
- Moved assembly extensions to ModUtils.cs
- Work to event service.
NetworkService work
- Added ImpromptuInterfaces package.
- Networking Service work to support NetVars
- Event Service
- Added assemblies references package for script compilation. Updated Roslyn version for compatibility.
- Package Loading work.
Swap Harmony to HarmonyX
- More refactor conversion to FluentResults.
- Updated StylesService to return Results.
- Refactor of PackageService partially complete.
- Made IService.Reset() required to return a Result.
- Moved plugin/assembly related code to their own folder (same namespace).
- Updated interfaces to reflect the use of Result<T>.
- Partial refactor, incomplete.
- Added 'FluentResults' so we can stop using cursed Exception-based flow control in loading code.
- Added 'OneOf' nuget package: https://github.com/mcintyre321/OneOf
for the implementation of the Optional<T> pattern and complex discrete return types instead of cursed enums (see current AssemblyManager.cs).
- Reapplied old branch changes.

Barotrauma/BarotraumaShared/SharedSource/LuaCs/LuaCsPerformanceCounter.cs

@@ -1,36 +1,81 @@
+using Barotrauma.LuaCs.Services;
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
+using System.Linq;
 
 namespace Barotrauma
 {
-    public class LuaCsPerformanceCounter
+    public interface IPerformanceData
     {
-        public bool EnablePerformanceCounter = false;
+        public string Identifier { get; }
+        public long ElapsedTicks { get; }
+    }
 
-        public double UpdateElapsedTime;
-        public Dictionary<string, Dictionary<string, double>> HookElapsedTime = new Dictionary<string, Dictionary<string, double>>();
+    public class SimplePerformanceData : IPerformanceData
+    {
+        public string Identifier { get; }
+        public long ElapsedTicks { get; }
 
-        public static float MemoryUsage
+        public SimplePerformanceData(string identifier, long elapsedTicks)
         {
-            get
-            {
-                Process proc = Process.GetCurrentProcess();
-                float memory = MathF.Round(proc.PrivateMemorySize64 / (1024 * 1024), 2);
-                proc.Dispose();
-
-                return memory;
-            }
-        }
-
-        public void SetHookElapsedTicks(string eventName, string hookName, long ticks)
-        {
-            if (!HookElapsedTime.ContainsKey(eventName)) 
-            { 
-                HookElapsedTime[eventName] = new Dictionary<string, double>(); 
-            }
-
-            HookElapsedTime[eventName][hookName] = (double)ticks / Stopwatch.Frequency;
+            Identifier = identifier;
+            ElapsedTicks = elapsedTicks;
         }
     }
-}
+
+    public class PerformanceCounterService : IReusableService
+    {
+        public bool EnablePerformanceCounter { get; set; } = false;
+
+        private Dictionary<string, List<IPerformanceData>> _data = new Dictionary<string, List<IPerformanceData>>();
+
+        public void AddElapsedTicks(IPerformanceData data)
+        {
+            if (!EnablePerformanceCounter) { return; }
+
+            if (!_data.ContainsKey(data.Identifier))
+            {
+                _data.Add(data.Identifier, new List<IPerformanceData>());
+            }
+
+            _data[data.Identifier].Add(data);
+
+            Trim(data.Identifier, 100);
+        }
+
+        public T GetLatestSnapshot<T>(string identifier) where T : class, IPerformanceData
+        {
+            if (!_data.ContainsKey(identifier)) { return default; }
+
+            return (T)_data[identifier].Last();
+        }
+
+        public T[] GetSnapshot<T>(string identifier, int length) where T : class, IPerformanceData, new()
+        {
+            if (!_data.ContainsKey(identifier)) { return new T[] { }; }
+
+            length = Math.Min(length, _data[identifier].Count);
+
+            return _data[identifier].GetRange(_data[identifier].Count - length, length).Cast<T>().ToArray();
+        }
+
+        public void Trim(string identifier, int maxSize)
+        {
+            if (!_data.ContainsKey(identifier)) { return; }
+
+            if (_data[identifier].Count > maxSize)
+            {
+                _data[identifier].RemoveRange(0, _data[identifier].Count - maxSize);
+            }
+        }
+
+        public FluentResults.Result Reset()
+        {
+            _data = new Dictionary<string, List<IPerformanceData>>();
+            return FluentResults.Result.Ok();
+        }
+
+        public void Dispose() { }
+    }
+}