[nativeaot] introduce Microsoft.Android.Runtime.NativeAOT.dll

[jonathanpeppers]

This moves:

• C# code from samples/NativeAOT to a new assembly, Microsoft.Android.Runtime.NativeAOT.dll.

• Java code from samples/NativeAOT to Xamarin.Android.Build.Tasks, to be generated at build time.

• C# code from Java.Interop.Environment.csproj has been trimmed down and moved to Microsoft.Android.Runtime.NativeAOT.dll as well.

[jonathanpeppers]

This is the major TODO, preventing this from working...

Need to figure out how we could make the app pass these in.

[jonpryor]

@jonathanpeppers asked:

short of "implement a C# typemap" is there a quick idea for doing this part?

I think the short answer is "no".

The longer answer is "what's the MVP for type maps?"

Maybe not immediately, but eventually type maps need to be able to access/reference internal types outside the app assembly, so source generators as a technique are out. Plus, source generators run on pre-linked input.

I think the MVP is:

1. Update NativeAotTypeManager to have, and ensure survives the linker:

   partial class NativeAotTypeManager {
       static IDictionary<string, Type> TypeMappings;
   
       static NativeAotTypeManager()
       {
           InitTypeMappings ();
       }
   
       static void InitTypeMappings ()
       {
           TypeMappings = new Dictionary<string, Type>();
       }
   }

2. Linker pipeline step (yay!) which processes the linked assemblies, so that it only references types which are actually used.

3. (2) uses Cecil to find NativeAotTypeManager and replace the body of NativeAotTypeManager.InitTypeMappings() with the equivalent of::

   partial class NativeAotTypeManager {
   
       static void InitTypeMappings ()
       {
           TypeMappings = new Dictionary<string, Type>();
           TypeMappings.Add ("net/dot/jni/ManagedPeer", typeof (Java.Interop.ManagedPeer));
           TypeMappings.Add ("java/lang/Object", typeof (Java.Lang.Object));
           // …
       }
   }

I assume (lol) that most of that should be reasonably straightforward to implement given our existing codebase. We already have linker pipeline steps, it's "reasonable" to figure out the IL version of typeof(T) and Dictionary.Add() calls.