fix: Adds ReadType/Write(Type) and improves type referencing (#1172)

## Changes
* Improves type hashing by introducing xxHash3 (64bit)
* Removes individual `tdb` files in favor of a single `SerializedTypes.db` file. This file is only used to identify a type that is being deserialized, which doesn't exist.
* Adds duplicate type alias detection
* Adds `AssemblyHandler.FindTypeByHash`

View changed files whitespaces: https://github.com/modernuo/ModernUO/pull/1172/files?diff=split&w=1

## SerializedTypes.db
The serialized types file is used to get back the original name of a type in case it no longer exists in code. This can easily be necessary if a class is renamed in code and no `TypeAlias` is provided.

### Format
byte[4] - version
byte[4] - count
--array--
byte[8] - xxHash
byte[1] - flag, 0 - null, 1 - not null
byte[n] - Full class name in UTF8

### Example
<img width="472" alt="SerializedTypes_Example" src="https://user-images.githubusercontent.com/3953314/195255429-31d24293-6bd1-419e-811b-07874dd0f78d.png">

## Benchmarks
Serialized 500 Type fields. The 8192bytes comes from the _ConcurrentQueue_ that would later be used for SerializedTypes.
Note that the queue is never cleared, so it's size grew considerably.
```cs
|               Method |     Mean |    Error |   StdDev | Allocated |
|--------------------- |---------:|---------:|---------:|----------:|
|      BenchmarkXXHash | 18.44 us | 0.278 us | 0.260 us |    8192 B |
| BenchmarkTypeStrings | 25.09 us | 0.292 us | 0.259 us |         - |
```

TODO:
* Add support in the Serialization Generator for `ReadType()` and `Write(Type)`
* Remove `SetTypeRef` from Serialization Generator

Projects/Server/Serialization/BinaryFileReader.cs

@@ -14,27 +14,34 @@
  *************************************************************************/
 
 using System;
+using System.Collections.Generic;
 using System.IO;
 using System.Runtime.CompilerServices;
 using System.Text;
 using Server.Buffers;
 using Server.Collections;
+using Server.Logging;
 using Server.Text;
 
 namespace Server;
 
 public class BinaryFileReader : IGenericReader, IDisposable
 {
+    private static readonly ILogger logger = LogFactory.GetLogger(typeof(BinaryFileReader));
+
+    private Dictionary<ulong, string> _typesDb;
     private BinaryReader _reader;
     private Encoding _encoding;
 
-    public BinaryFileReader(BinaryReader br, Encoding encoding = null)
+    public BinaryFileReader(BinaryReader br, Dictionary<ulong, string> typesDb = null, Encoding encoding = null)
     {
         _reader = br;
         _encoding = encoding ?? TextEncoding.UTF8;
+        _typesDb = typesDb;
     }
 
-    public BinaryFileReader(Stream stream, Encoding encoding = null) : this(new BinaryReader(stream), encoding)
+    public BinaryFileReader(Stream stream, Dictionary<ulong, string> typesDb = null, Encoding encoding = null)
+        : this(new BinaryReader(stream), typesDb, encoding)
     {
     }
 
@@ -46,23 +53,20 @@ public class BinaryFileReader : IGenericReader, IDisposable
     public DateTime LastSerialized { get; init; }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public string ReadString(bool intern = false)
-    {
-        if (!ReadBool())
-        {
-            return null;
-        }
+    public string ReadString(bool intern = false) => ReadBool() ? ReadStringRaw(intern) : null;
 
+    public string ReadStringRaw(bool intern = false)
+    {
         var length = ((IGenericReader)this).ReadEncodedInt();
         if (length <= 0)
         {
-            return intern ? Utility.Intern("") : "";
+            return "".Intern();
         }
 
         byte[] buffer = STArrayPool<byte>.Shared.Rent(length);
         var str = TextEncoding.GetString(buffer.AsSpan(0, length), _encoding);
         STArrayPool<byte>.Shared.Return(buffer);
-        return intern ? Utility.Intern(str) : str;
+        return intern ? str.Intern() : str;
     }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -101,6 +105,62 @@ public class BinaryFileReader : IGenericReader, IDisposable
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public Serial ReadSerial() => (Serial)_reader.ReadUInt32();
 
+    public Type ReadType() =>
+        ReadByte() switch
+        {
+            0 => null,
+            1 => AssemblyHandler.FindTypeByFullName(ReadStringRaw()), // Backward compatibility
+            2 => ReadTypeByHash()
+        };
+
+    public Type ReadTypeByHash()
+    {
+        var hash = ReadULong();
+        var t = AssemblyHandler.FindTypeByHash(hash);
+
+        if (t != null)
+        {
+            return t;
+        }
+
+        if (_typesDb == null)
+        {
+            logger.Error(
+                new Exception($"The file SerializedTypes.db was not loaded. Type hash '{hash}' could not be found."),
+                "Invalid {Hash} at position {Position}",
+                hash,
+                Position
+            );
+
+            return null;
+        }
+
+        if (!_typesDb.TryGetValue(hash, out var typeName))
+        {
+            logger.Error(
+                new Exception($"Type hash '{hash}' is not present in the serialized types database."),
+                "Invalid type hash {Hash} at position {Position}",
+                hash,
+                Position
+            );
+
+            return null;
+        }
+
+        t = AssemblyHandler.FindTypeByFullName(typeName, false);
+
+        if (t == null)
+        {
+            logger.Error(
+                new Exception($"Type '{typeName}' was not found."),
+                "Type {Type} was not found.",
+                typeName
+            );
+        }
+
+        return t;
+    }
+
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public int Read(Span<byte> buffer) => _reader.Read(buffer);