Update/fix HasSyncWorker method (#444)

This will prevent a bunch of errors (mostly harmless, main downside is that it would allow duplicate sync workers to be registered).

- The method we were called is no longer static, so we need to get the instance of `SyncSerialization`
- `SyncSerialization` was moved from Client to Common, but it does not really matter as we need to get the instance from Client anyway
- Added code to get the field holding `SyncSerialization` instance, with additional checks to make sure it's not null, the field is static, and the actual instance is not null
- Changed the code to access the method to use the type of the field we've accessed, rather than using the full path
- Added code to check if the method is static and show a warning if it is (as we're expecting it to be non-static)
- Simplified error logging by using a local function that will call `Log.Error` with the same text at the beginning, rather than that text being copy-pasted all the time

Source/MpSyncWorkers.cs

@@ -110,24 +110,54 @@ private static void SyncDesignationManager(SyncWorker sync, ref DesignationManag
 
         private static bool HasSyncWorker(Type type)
         {
-            const string methodPath = "Multiplayer.Client.SyncSerialization:CanHandle";
+            const string fieldPath = "Multiplayer.Client.Multiplayer:serialization";
+            const string methodName = "CanHandle";
+            void Error(string message) => Log.Error($"Failed to check if sync worker for type {type} is already registered in MP - {message}");
 
-            // Don't cache the method, it'll be used very rarely (assuming it'll even be used at all), so there's no point in having a field for it.
-            var method = AccessTools.DeclaredMethod(methodPath, new[] { typeof(SyncType) });
+            // Don't cache the field/method, they will be used very rarely (assuming they will even be used at all), so there's no point in having a field for it.
+            var field = AccessTools.DeclaredField(fieldPath);
+
+            if (field == null)
+            {
+                Error($"failed to find field {fieldPath}");
+                return false;
+            }
+
+            if (!field.IsStatic)
+            {
+                Error($"field {fieldPath} is not static");
+                return false;
+            }
+
+            var instance = field.GetValue(null);
+
+            if (instance == null)
+            {
+                Error($"field {fieldPath} is null");
+                return false;
+            }
+
+            var method = AccessTools.DeclaredMethod(field.FieldType, methodName, [typeof(SyncType)]);
 
             if (method == null)
             {
-                Log.Error($"Failed to check if sync worker for type {type} is already registered in MP - failed to find method {methodPath}");
+                Error($"failed to find method {methodName}");
                 return false;
             }
 
             if (method.ReturnType != typeof(bool))
             {
-                Log.Error($"Failed to check if sync worker for type {type} is already registered in MP - return type is not bool but {method.ReturnType} for method {methodPath}");
+                Error($"return type is not bool but {method.ReturnType} for method {methodName}");
                 return false;
             }
 
-            return (bool)method.Invoke(null, new object[] { new SyncType(type) });
+            if (method.IsStatic)
+            {
+                Log.Warning($"Method {methodName} is static, but we expected it to be non-static - the results may potentially be incorrect.");
+                return (bool)method.Invoke(null, [new SyncType(type)]);
+            }
+
+            return (bool)method.Invoke(instance, [new SyncType(type)]);
         }
     }
 }