Avoid multiple java/lang/Object bindings.

A funny thing happened when b9aa5f7 ran on xamarin-android:
unit tests started crashing!

	E monodroid-assembly: typemap: unable to load assembly 'Java.Interop-Tests' when looking up managed type corresponding to Java type 'java/lang/Object'

What appears to be happening is an Unfortunate Interaction™:

 1. `Java.Interop-Tests.dll` contained *multiple bindings* for
    `java/lang/Object`. e.g.

        [JniTypeSignature ("java/lang/Object", GenerateJavaPeer=false)]
        partial class JavaDisposedObject : JavaObject {
        }

 2. The typemap generator has no functionality to "prioritize" one
    binding vs. another; it's random.  As such, there is nothing to
    cause `Java.Lang.Object` to be used as the preferred binding for
    `java/lang/Object`.

This meant that when we hit the typemap codepath in .NET Android,
we looked for the C# type that corresponded to `java/lang/Object`,
found *some random type* from `Java.Interop-Tests`, and…

…and then we hit another oddity: that codepath only supported looking
for C# types in assemblies which had already been loaded.  This was
occurring during startup, so `Java.Interop-Tests` had not yet been
loaded yet, so it errored out, returned `nullptr`, and later Android
just aborts things:

	F droid.NET_Test: runtime.cc:638] JNI DETECTED ERROR IN APPLICATION: use of deleted local reference 0x79

Just…eep!

This didn't happen before because `Java.Interop.JavaObject` subclasses
*didn't* participate in typemap generation.  b9aa5f7 *added* that
support, introducing this unforeseen interaction.

Fix this by *removing* all "alternate bindings" for `java/lang/Object`:

	- [JniTypeSignature ("java/lang/Object", GenerateJavaPeer=false)]
	+ [JniTypeSignature (JniTypeName)]
          partial class JavaDisposedObject : JavaObject {
              internal const string JniTypeName = "net/dot/jni/test/JavaDisposedObject";
          }

This implicitly requires that we now have a Java Callable Wrapper
for this type, so update `Java.Interop-Tests.csproj` to run `jcw-gen`
as part of the build process.  This ensures that we create the
JCW for e.g. `JavaDisposedObject`.

Finally, update `JavaVMFixture` to add the required typemap entries.

These changes should allow .NET Android unit tests to run w/o crashing.

tests/Java.Interop-Tests/Java.Interop-Tests.targets

@@ -1,12 +1,47 @@
 <Project>
 
+  <ItemGroup>
+    <_BuildJavaInteropTestsJarInputs Include="$(TargetPath)" />
+    <_BuildJavaInteropTestsJarInputs Include="$(MSBuildThisFileFullPath)" />
+    <_BuildJavaInteropTestsJarInputs Include="java\**\*.java" />
+  </ItemGroup>
+
+  <Target Name="_CreateJavaCallableWrappers"
+      Condition=" '$(TargetPath)' != '' "
+      AfterTargets="Build"
+      Inputs="@(_BuildJavaInteropTestsJarInputs)"
+      Outputs="$(IntermediateOutputPath)java\.stamp">
+    <RemoveDir Directories="$(IntermediateOutputPath)java" />
+    <MakeDir Directories="$(IntermediateOutputPath)java" />
+    <ItemGroup>
+      <!-- I can't find a good way to trim the trailing `\`, so append with `.` so we can sanely quote for $(_Libpath) -->
+      <_RefAsmDirs Include="@(ReferencePathWithRefAssemblies->'%(RootDir)%(Directory).'->Distinct())" />
+    </ItemGroup>
+    <PropertyGroup>
+      <_JcwGen>"$(UtilityOutputFullPath)/jcw-gen.dll"</_JcwGen>
+      <_Target>--codegen-target JavaInterop1</_Target>
+      <_Output>-o "$(IntermediateOutputPath)/java"</_Output>
+      <_Libpath>@(_RefAsmDirs->'-L "%(Identity)"', ' ')</_Libpath>
+    </PropertyGroup>
+    <Exec Command="$(DotnetToolPath) $(_JcwGen) -v &quot;$(TargetPath)&quot; $(_Target) $(_Output) $(_Libpath)" />
+    <Touch Files="$(IntermediateOutputPath)java\.stamp" AlwaysCreate="True" />
+  </Target>
+
+  <Target Name="_CollectGeneratdJcwSource">
+    <ItemGroup>
+      <_GeneratedJcwSource Include="$(IntermediateOutputPath)java\**\*.java" />
+    </ItemGroup>
+  </Target>
+
   <Target Name="BuildInteropTestJar"
-      BeforeTargets="Build"
-      Inputs="@(JavaInteropTestJar)"
+      AfterTargets="Build"
+      DependsOnTargets="_CreateJavaCallableWrappers;_CollectGeneratdJcwSource"
+      Inputs="@(JavaInteropTestJar);@(_GeneratedJcwSource)"
       Outputs="$(OutputPath)interop-test.jar">
     <MakeDir Directories="$(IntermediateOutputPath)it-classes" />
     <ItemGroup>
       <_Source Include="@(JavaInteropTestJar->Replace('%5c', '/'))" />
+      <_Source Include="@(_GeneratedJcwSource->Replace('%5c', '/'))" />
     </ItemGroup>
     <WriteLinesToFile
         File="$(IntermediateOutputPath)_java_sources.txt"

tests/Java.Interop-Tests/Java.Interop/JavaObjectTest.cs

@@ -164,11 +164,13 @@ public void Ctor_Exceptions ()
 			var r   = new JniObjectReference ();
 			Assert.Throws<ArgumentException> (() => new JavaObject (ref r, JniObjectReferenceOptions.CopyAndDispose));
 
-			// Note: This may break if/when JavaVM provides "default"
-			Assert.Throws<NotSupportedException> (() => new JavaObjectWithNoJavaPeer ());
 #if __ANDROID__
 			Assert.Throws<Java.Lang.ClassNotFoundException> (() => new JavaObjectWithMissingJavaPeer ()).Dispose ();
 #else   // !__ANDROID__
+			// Note: `JavaObjectWithNoJavaPeer` creation works on Android because tooling provides all
+			// typemap entries.  On desktop, we use the hardcoded cit in JavaVMFixture, which deliberately
+			// *lacks* an  entry for `JavaObjectWithNoJavaPeer`.
+			Assert.Throws<NotSupportedException> (() => new JavaObjectWithNoJavaPeer ());
 			Assert.Throws<JavaException> (() => new JavaObjectWithMissingJavaPeer ()).Dispose ();
 #endif  // !__ANDROID__
 		}
@@ -201,17 +203,21 @@ public void DisposeAccessesThis ()
 		}
 	}
 
+#if !__ANDROID__
 	class JavaObjectWithNoJavaPeer : JavaObject {
 	}
+#endif  // !__ANDROID__
 
 	[JniTypeSignature (JniTypeName, GenerateJavaPeer=false)]
 	class JavaObjectWithMissingJavaPeer : JavaObject {
 		internal    const   string  JniTypeName = "__this__/__type__/__had__/__better__/__not__/__Exist__";
 	}
 
-	[JniTypeSignature ("java/lang/Object", GenerateJavaPeer=false)]
+	[JniTypeSignature (JniTypeName)]
 	class JavaDisposedObject : JavaObject {
 
+		internal    const   string  JniTypeName = "net/dot/jni/test/JavaDisposedObject";
+
 		public Action   OnDisposed;
 		public Action   OnFinalized;
 
@@ -230,8 +236,10 @@ protected override void Dispose (bool disposing)
 		}
 	}
 
-	[JniTypeSignature ("java/lang/Object", GenerateJavaPeer=false)]
+	[JniTypeSignature (JniTypeName)]
 	class MyDisposableObject : JavaObject {
+		internal    const   string  JniTypeName = "net/dot/jni/test/MyDisposableObject";
+
 		bool _isDisposed;
 
 		public MyDisposableObject ()

tests/Java.Interop-Tests/Java.Interop/JavaVMFixture.cs

@@ -40,6 +40,9 @@ class JavaVMFixtureTypeManager : JniRuntime.JniTypeManager {
 			[CallVirtualFromConstructorBase.JniTypeName]    = typeof (CallVirtualFromConstructorBase),
 			[CallVirtualFromConstructorDerived.JniTypeName] = typeof (CallVirtualFromConstructorDerived),
 			[GetThis.JniTypeName]                           = typeof (GetThis),
+			[JavaDisposedObject.JniTypeName]                = typeof (JavaDisposedObject),
+			[JavaObjectWithMissingJavaPeer.JniTypeName]     = typeof (JavaObjectWithMissingJavaPeer),
+			[MyDisposableObject.JniTypeName]                = typeof (JavaDisposedObject),
 		};
 
 		public JavaVMFixtureTypeManager ()