feat(core): Makes spanwriter resizable (#376)

SpanWriter now has an argument that allows it to be resizable.
```cs
public SpanWriter(Span<byte> initialBuffer, bool resize = false)
public SpanWriter(int initialCapacity, bool resize = false)
```

If a SpanWriter is set to be resizable, or given an initial capacity instead of a buffer, it must be disposed:
```cs
public static void SomeMethod()
{
    using var writer = new SpanWriter(stackalloc byte[512], true);
    // stuff
    
    // Automatic Dispose of writer
}
```

This is because the SpanWriter uses `ArrayPool<byte>.Shared` _rented buffers_ to resize. If the writer is not disposed, those buffers will never be reused resulting in a _memory leak_.

It is possible that the SpanWriter will outright ditch the initial buffer if resize is set to true and growing is needed. To check/account for that we can do the following:

```cs
public static void SomeMethod()
{
    Span<byte> span = stackalloc byte[512];
    using var writer = new SpanWriter(span, true);
    // write some stuff that causes the span to grow
    
    span = writer.RawBuffer;
    // Do stuff with the span
}
```

Make sure you don't accidentally `Dispose()` the writer or use the `RawBuffer` outside of the `using` block. If you do, bad things will happen! (NullPointerException, or a fresh SpanWriter with no buffer, depending on the situation).

SpanWriter can also now be used with a fixed statement since it has a `PinnableReference()` function.

Projects/Server.Tests/Server.Tests.csproj

@@ -3,7 +3,7 @@
         <IsPackable>false</IsPackable>
     </PropertyGroup>
     <ItemGroup>
-        <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.7.1" />
+        <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.9.0-preview-20201123-03" />
         <PackageReference Include="xunit" Version="2.4.1" />
         <PackageReference Include="xunit.runner.visualstudio" Version="2.4.3" />
         <PackageReference Include="coverlet.collector" Version="1.3.0" />

Projects/Server.Tests/Tests/Buffers/SpanWriterTests.cs

@@ -0,0 +1,63 @@
+using System;
+using System.Buffers;
+using Xunit;
+
+namespace Server.Tests
+{
+    public class SpanWriterTests
+    {
+        [Fact]
+        public unsafe void TestSpanWriterResizes()
+        {
+            Span<byte> smallStack = stackalloc byte[8];
+            using var writer = new SpanWriter(smallStack, true);
+            writer.Write(0x1024L);
+            writer.Write(0x1024L);
+
+            var span = writer.RawBuffer;
+            fixed (byte* spanPtr = span)
+            {
+                fixed (byte* stackPtr = smallStack)
+                {
+                    Assert.True(spanPtr != stackPtr);
+                }
+            }
+
+            Assert.True(span.Length > smallStack.Length);
+        }
+
+        [Fact]
+        public unsafe void TestSpanWriterOnlyStackAlloc()
+        {
+            Span<byte> smallStack = stackalloc byte[8];
+            using var writer = new SpanWriter(smallStack, true);
+            writer.Write(0x1024L);
+
+            var span = writer.RawBuffer;
+            fixed (byte* spanPtr = span)
+            {
+                fixed (byte* stackPtr = smallStack)
+                {
+                    Assert.True(spanPtr == stackPtr);
+                }
+            }
+
+            Assert.True(span.Length == smallStack.Length);
+            AssertThat.Equal(smallStack, stackalloc byte[] { 0, 0, 0, 0, 0, 0, 0x10, 0x24 });
+        }
+
+        [Fact]
+        public void TestSpanWriterNoResizeThrows()
+        {
+            Assert.Throws<OutOfMemoryException>(
+                () =>
+                {
+                    Span<byte> smallStack = stackalloc byte[8];
+                    using var writer = new SpanWriter(smallStack);
+                    writer.Write(0x1024L);
+                    writer.Write(0x1024L);
+                }
+            );
+        }
+    }
+}