[JavaCallableWrappers] Parallel.ForEach per assembly

Since we are looking at every type in each assembly, we can
parallelize this work to make things a bit faster.

However, there are a few concerns when doing this:
- Made sure to add a *new* method `GetJavaTypesInParallel` so the
  caller can opt-in to this
- The `cache` in `DirectoryAssemblyResolver` needs to now be a
  `ConcurrentDictionary`
- The list of `javaTypes` returned by `JavaTypeScanner` needs to also
  use a `BlockingCollection`
- Downstream in `xamarin-android`, we need to make sure
  `GenerateJavaStubs` is now an `AsyncTask`, so the "thread safe"
  logger methods are used.

To time the improvements, I used this project in Xamarin.Forms:
https://github.com/xamarin/Xamarin.Forms/tree/master/Xamarin.Forms.ControlGallery.Android

Before I did anything, the times were:

    2594 ms  GenerateJavaStubs                          2 calls

After making things parallel:

    2143 ms  GenerateJavaStubs                          2 calls

And then after a few more LINQ improvements in the `GenerateJavaStubs`
MSBuild task:

    2104 ms  GenerateJavaStubs                          2 calls

So we have close to a 500ms improvement for `GenerateJavaStubs` in
this project, that will build a library project + application project.

To see the full changes required downstream in `xamarin-android`:
dotnet/android@master...jonathanpeppers:generatejavastubs-perf

Author: jonathanpeppers

src/Java.Interop.Tools.Cecil/Java.Interop.Tools.Cecil/DirectoryAssemblyResolver.cs

@@ -29,7 +29,7 @@
 
 using System;
 using System.Diagnostics;
-using System.Collections;
+using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
@@ -61,7 +61,7 @@ public class DirectoryAssemblyResolver : IAssemblyResolver {
 
 		public ICollection<string> SearchDirectories {get; private set;}
 
-		Dictionary<string, AssemblyDefinition> cache;
+		ConcurrentDictionary<string, AssemblyDefinition> cache;
 		bool loadDebugSymbols;
 		Action<TraceLevel, string>              logger;
 
@@ -82,7 +82,7 @@ public DirectoryAssemblyResolver (Action<TraceLevel, string> logger, bool loadDe
 		{
 			if (logger == null)
 				throw new ArgumentNullException (nameof (logger));
-			cache = new Dictionary<string, AssemblyDefinition> ();
+			cache = new ConcurrentDictionary<string, AssemblyDefinition> ();
 			this.loadDebugSymbols = loadDebugSymbols;
 			this.logger       = logger;
 			SearchDirectories = new List<string> ();

src/Java.Interop.Tools.JavaCallableWrappers/Java.Interop.Tools.JavaCallableWrappers/JavaTypeScanner.cs

@@ -1,12 +1,12 @@
 using System;
+using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Linq;
-using System.Text;
+using System.Threading.Tasks;
 using Mono.Cecil;
 
 using Java.Interop.Tools.Cecil;
-using Java.Interop.Tools.Diagnostics;
 using Java.Interop.Tools.TypeNameMappings;
 
 namespace Java.Interop.Tools.JavaCallableWrappers
@@ -29,23 +29,38 @@ public List<TypeDefinition> GetJavaTypes (IEnumerable<string> assemblies, IAssem
 
 			foreach (var assembly in assemblies) {
 				var assm = resolver.GetAssembly (assembly);
-
 				foreach (ModuleDefinition md in assm.Modules) {
 					foreach (TypeDefinition td in md.Types) {
-						AddJavaTypes (javaTypes, td);
+						AddJavaTypes (javaTypes.Add, td);
 					}
 				}
 			}
 
 			return javaTypes;
 		}
 
-		void AddJavaTypes (List<TypeDefinition> javaTypes, TypeDefinition type)
+		public List<TypeDefinition> GetJavaTypesInParallel (IEnumerable<string> assemblies, IAssemblyResolver resolver)
+		{
+			var javaTypes = new BlockingCollection<TypeDefinition> ();
+
+			Parallel.ForEach (assemblies, assembly => {
+				var assm = resolver.GetAssembly (assembly);
+				foreach (ModuleDefinition md in assm.Modules) {
+					foreach (TypeDefinition td in md.Types) {
+						AddJavaTypes (javaTypes.Add, td);
+					}
+				}
+			});
+
+			return javaTypes.ToList ();
+		}
+
+		void AddJavaTypes (Action<TypeDefinition> addMethod, TypeDefinition type)
 		{
 			if (type.IsSubclassOf ("Java.Lang.Object") || type.IsSubclassOf ("Java.Lang.Throwable")) {
 
 				// For subclasses of e.g. Android.App.Activity.
-				javaTypes.Add (type);
+				addMethod (type);
 			} else if (type.IsClass && !type.IsSubclassOf ("System.Exception") && type.ImplementsInterface ("Android.Runtime.IJavaObject")) {
 				var level   = ErrorOnCustomJavaObject ? TraceLevel.Error : TraceLevel.Warning;
 				var prefix  = ErrorOnCustomJavaObject ? "error" : "warning";
@@ -59,7 +74,7 @@ void AddJavaTypes (List<TypeDefinition> javaTypes, TypeDefinition type)
 				return;
 
 			foreach (TypeDefinition nested in type.NestedTypes)
-				AddJavaTypes (javaTypes, nested);
+				AddJavaTypes (addMethod, nested);
 		}
 
 		public static bool ShouldSkipJavaCallableWrapperGeneration (TypeDefinition type)