perf: Reduce the amount of redundant 'Change' data serialized by SyncDictionary

[cshunsinger]

New logic is added here to track the changes that get made to a SyncDictionary which drastically reduces the amount of redundant data being sent over the network.

Now if several modifications get made to the same key, whether it is add/set/remove/clear, there will not be multiple "Change" entries recorded.

For example, if a dictionary has 10 different keys, and if each of the 10 keys have their values added/removed/set 1000 times each in a single frame, then there will still only be 10 "Change" elements.

A "Clear" operation will also clear all tracked "Changes". So in the above example where there are 10 changes, performing a OP_CLEAR operation would also destroy those 10 "Changes" and replace them with a single "Change" representing the OP_CLEAR.

The only exception to the above is this: OnSerializeAll, which will ensure that all existing changes will still be transmitted during the next OnSerializeDelta along with at-most 1 additional change for every distinct dictionary slot that gets modified at least once. This is the one situation where there might be a limited quantity of redundant "Changes" that get transmitted, but this is still limited.

Finally, while the default behavior of SyncDictionary is modified by these changes to prevent sending redundant change details, a boolean flag can be optionally passed to the SyncDictionary constructor. If set to true, the SyncDictionary will use the "old" method of tracking every single change regardless of whether or not the changes are redundant.

Please don't roast me too hard. I was just looking into some of Mirror's code and saw a TODO and thought I'd get some practice.

[MrGadget1024]

To make this backward compatible and non-breaking, syncAllChanges must default to true as an optional param in the constructor.

[cshunsinger]

Makes sense. I'll tweak it after work. I'm gonna rename and refactor the boolean in that case so that false means "send all changes" because I don't like bools being true by default in an optional param.

[cshunsinger]

The default behavior is now updated so that SyncDictionary will work as it always has. Setting the dictionary flag to true in the constructor will enable it to only send a limited quantity of changes per field.

[imerr]

Looking pretty good to me, any chance you can add tests?
As a start replacing

Mirror/Assets/Mirror/Tests/Editor/SyncCollections/SyncDictionaryTest.cs

Lines 7 to 9 in 5411066

	[TestFixture]
	public class SyncDictionaryTest
	{

with

    [TestFixture(false)]
    [TestFixture(true)]
    public class SyncDictionaryTest
    {
        private bool optimized;
        public SyncDictionaryTest(bool optimized)
        {
            this.optimized = optimized;
        }

and creating the syncdict's with the optimized flags in Setup

        [SetUp]
        public void SetUp()
        {
            serverSyncDictionary = new SyncDictionary<int, string>(optimized);
            clientSyncDictionary = new SyncDictionary<int, string>(optimized);

would run tests in both modes (which passes currently)

[MrGadget1024]

@cshunsinger If unit tests are beyond your skill level, just say so and we'll work them up for you.
Sorry this has been delayed, but we're finally able to look at outstanding PR's for merging.

[cshunsinger]

I'll add the unit tests.
Sorry for not responding sooner, just very busy at the moment with my day job and a toddler.