[Java.Interop] Support Desugar + interface static methods

[jonpryor]

Context: 1f27ab5
Context: dotnet/android@f6f11a5
Context: dotnet/android#7663 (comment)

Commit 1f27ab5 added partial support for desugaring, which
rewrites Java bytecode so that default interface methods and
static methods in interfaces can be supported on pre-Android 7.0
(API-24) devices, as the pre-API-24 ART runtime does not directly
support those bytecode constructs.

The hope was that commit 1f27ab5 in concert with
dotnet/android@f6f11a5a would allow static methods on
interfaces to work, by having
Java.Interop.JniPeerMembers.JniStaticMethods.GetMethodInfo()
call JniRuntime.JniTypeManager.GetStaticMethodFallbackTypes().
xamarin/xamarin-android would then override
GetStaticMethodFallbackTypes(), allowing GetMethodInfo() to
instead resolve the static method from the fallback type, allowing
the static method invocation to work.

TODO: Update xamarin-android to override
GetStaticMethodFallbackTypes(), to return
$"{jniSimpleReference}$-CC".

What actually happened? Not enough testing happened, such that
when it was actually attempted, it blew up bigly:

JNI DETECTED ERROR IN APPLICATION: can't call static int com.xamarin.android.StaticMethodsInterface$-CC.getValue() with class java.lang.Class<com.xamarin.android.StaticMethodsInterface>
    in call to CallStaticIntMethodA
    from void crc641149b9fe658fbe8e.MainActivity.n_onCreate(android.os.Bundle)

Oops.

What went wrong?

The problem is that JNIEnv::CallStatic*Method() requires that
we provide the jclass clazz value for the type that declares the
static method, but we're providing the wrong class!

Specifically, consider this Java interface:

public interface StaticMethodsInterface {
    static int getValue() {
        return 3;
    }
}

In a desugared environment, this is transformed into the pair of
types:

public interface StaticMethodsInterface {
}
public class StaticMethodsInterface$-CC {
    public static int getValue() {
        return 3;
    }
}

GetStaticMethodFallbackTypes("StaticMethodsInterface") returns
StaticMethodsInterface$-CC, allowing GetMethodInfo() to lookup
StaticMethodsInterface$-CC and resolve the method
getValue.()I. However, when
JniPeerMembers.JniStaticMethods.Invoke*Method() is later invoked,
the jclass value for StaticMethodsInterface is provided, not
the value for StaticMethodsInterface$-CC. It's as if we do:

var from = new Java.Interop.JniType ("com/xamarin/android/StaticMethodsInterface");
var to   = new Java.Interop.JniType ("com/xamarin/android/StaticMethodsInterface$-CC");
var m    = to.GetStaticMethod ("getValue", "()I");
var r    = Java.Interop.JniEnvironment.StaticMethods.CallStaticIntMethod (from.PeerReference, m);

The problem is that we need to use to.PeerReference, not
from.PeerReference!

Fix GetMethodInfo() so that when a method is resolved from a
fallback type, the type instance is stored in the
JniMethodInfo.StaticRedirect field, and then update the
Invoke*Method() methods so that JniMethodInfo.StaticRedirect is
passed to JNIEnv::CallStatic*Method() if it is set, before
defaulting to JniPeerMembers.JniPeerType.

"Optimization opportunity": the approach taken does not attempt to
cache the JniType instances which correspond to the fallback types.
Consequently, it is possible that multiple GREFs could be consumed
for the JniMethodInfo.StaticRedirect instances, as each instance
will be unique. This was done for expediency, and because @jonpryor
doesn't know if this will be an actual problem in practice.

Unrelatedly, fix the JniPeerMembers (string, Type, bool) constructor
so that it participates in type remapping. Without this change,
interface types cannot be renamed by the 1f27ab5 infrastructure.