[Java.Interop] Use lock+Dictionary, not ConcurrentDictionary (#791)

Context: dotnet/android#5455
Context: #791 (comment)
Context: https://devblogs.microsoft.com/oldnewthing/20201112-00/?p=104444
Context: https://www.drdobbs.com/cpp/avoid-calling-unknown-code-while-inside/202802983

We would like to further reduce the `.apk` size of Xamarin.Android's
`samples/HelloWorld` sample, and an *unnecessary contribution* to
`.apk` size is the use of [`ConcurrentDictionary<TKey, TValue>`][0]
within `Java.Interop.JniRuntime`.

Replacing `ConcurrentDictionary<TKey, TValue>` with a
`lock` + `Dictionary<TKey, TValue>` saves ~9.5KB in IL, by dropping
the `System.Collections.Concurrent.dll` reference:

	Size difference in bytes ([*1] apk1 only, [*2] apk2 only):
	  +          22 assemblies/Java.Interop.dll
	  -         316 assemblies/System.Private.CoreLib.dll
	  -         702 assemblies/System.Linq.dll
	  -       8,471 assemblies/System.Collections.Concurrent.dll *1
	Summary:
	  -       9,467 Assemblies -1.32% (of 719,277)
	  -      15,872 Uncompressed assemblies -1.06% (of 1,491,456) 

Additionally, `ConcurrentDictionary<TKey, TValue>` is *slower* than
`lock` + `Dictionary` for infrequently contested locks (8cdb16d).

Finally, fix a potential deadlock: it is *inadvisable* to invoke
"unknown code" from within a lock, as you don't know what that code
will do -- it could *call back into* the method holding the lock!

Address this theoretical deadlock by updating
`JniRuntime.ClearTrackedReferences()` to "capture" all of the
`IDisposable` instances that need to be disposed within the lock,
but waiting until we're *outside* the lock to execute them.
This avoids possible deadlock.

[0]: https://docs.microsoft.com/en-us/dotnet/api/system.collections.concurrent.concurrentdictionary-2?redirectedfrom=MSDN&view=net-5.0

Author: radekdoulik

src/Java.Interop/Java.Interop/JniRuntime.cs

@@ -1,7 +1,6 @@
 #nullable enable
 
 using System;
-using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Linq;
@@ -168,7 +167,7 @@ public static void SetCurrent (JniRuntime newCurrent)
 			current = newCurrent;
 		}
 
-		ConcurrentDictionary<IntPtr, IDisposable>       TrackedInstances    = new ConcurrentDictionary<IntPtr, IDisposable> ();
+		Dictionary<IntPtr, IDisposable>                 TrackedInstances    = new Dictionary<IntPtr, IDisposable> ();
 
 		JavaVMInterface                                 Invoker;
 		bool                                            DestroyRuntimeOnDispose;
@@ -403,21 +402,30 @@ public int WeakGlobalReferenceCount {
 
 		internal void Track (JniType value)
 		{
-			TrackedInstances.TryAdd (value.PeerReference.Handle, value);
+			lock (TrackedInstances) {
+				if (!TrackedInstances.ContainsKey (value.PeerReference.Handle))
+					TrackedInstances [value.PeerReference.Handle] = value;
+			}
 		}
 
 		internal void UnTrack (IntPtr key)
 		{
-			TrackedInstances.TryRemove (key, out var _);
+			lock (TrackedInstances) {
+				if (TrackedInstances.ContainsKey (key))
+					TrackedInstances.Remove (key);
+			}
 		}
 
 		void ClearTrackedReferences ()
 		{
-			foreach (var k in TrackedInstances.Keys.ToList ()) {
-				if (TrackedInstances.TryRemove (k, out var d))
-					d.Dispose ();
+			List<IDisposable> values;
+			lock (TrackedInstances) {
+				values = new List<IDisposable> (TrackedInstances.Values);
+				TrackedInstances.Clear ();
 			}
-			TrackedInstances.Clear ();
+
+			foreach (var d in values)
+				d.Dispose ();
 		}
 
 		public virtual bool ExceptionShouldTransitionToJni (Exception e)