Make our Android builds work with an Android bootclasspath.

Notably:

- Remove all usages of `AnnotatedType` from the Android flavor.
- Make `NullPointerTester` a no-op in the Android flavor (instead of only in the Android flavor _when running under an Android VM_).
  - (This requires removing its tests from the Android flavor entirely, rather than merely skipping them during our internal Android-VM test runs.)

In both cases, these changes apply only to (a) guava-android and (b) our actual internal _Android_ builds. In contrast, in the internal copy of the backport _that we test under a JRE_, the `AnnotatedType` APIs are still in place, and `NullPointerTester` still runs.

RELNOTES=`reflect`: In `guava-android` only, removed `Invokable.getAnnotatedReturnType()` and `Parameter.getAnnotatedType()`. These methods never worked in an Android VM, and to reflect that, they were born `@Deprecated`, `@Beta`, and `@DoNotCall`. They're now preventing us from rolling out some new Android compatibility testing.
PiperOrigin-RevId: 583032835

android/guava-testlib/src/com/google/common/testing/NullPointerTester.java

@@ -35,15 +35,13 @@
 import com.google.common.reflect.TypeToken;
 import com.google.errorprone.annotations.CanIgnoreReturnValue;
 import java.lang.annotation.Annotation;
-import java.lang.reflect.AnnotatedType;
 import java.lang.reflect.Constructor;
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Member;
 import java.lang.reflect.Method;
 import java.lang.reflect.Modifier;
 import java.lang.reflect.ParameterizedType;
 import java.lang.reflect.Type;
-import java.lang.reflect.TypeVariable;
 import java.util.Arrays;
 import java.util.List;
 import java.util.concurrent.ConcurrentMap;
@@ -353,9 +351,9 @@ private void testParameter(
       @Nullable Object instance, Invokable<?, ?> invokable, int paramIndex, Class<?> testedClass) {
     /*
      * com.google.common is starting to rely on type-use annotations, which aren't visible under
-     * Android VMs. So we skip testing there.
+     * Android VMs and in open-source guava-android. So we skip testing there.
      */
-    if (isAndroid() && Reflection.getPackageName(testedClass).startsWith("com.google.common")) {
+    if (Reflection.getPackageName(testedClass).startsWith("com.google.common")) {
       return;
     }
     if (isPrimitiveOrNullable(invokable.getParameters().get(paramIndex))) {
@@ -612,39 +610,19 @@ private static boolean annotatedTypeExists() {
    * don't know that anyone uses it there, anyway.
    */
   private enum NullnessAnnotationReader {
-    // Usages (which are unsafe only for Android) are guarded by the annotatedTypeExists() check.
-    @SuppressWarnings({"Java7ApiChecker", "AndroidApiChecker", "DoNotCall", "deprecation"})
+    @SuppressWarnings("Java7ApiChecker")
     FROM_DECLARATION_AND_TYPE_USE_ANNOTATIONS {
       @Override
-      @IgnoreJRERequirement
       boolean isNullable(Invokable<?, ?> invokable) {
         return FROM_DECLARATION_ANNOTATIONS_ONLY.isNullable(invokable)
-            || containsNullable(invokable.getAnnotatedReturnType().getAnnotations());
+        ;
         // TODO(cpovirk): Should we also check isNullableTypeVariable?
       }
 
       @Override
-      @IgnoreJRERequirement
       boolean isNullable(Parameter param) {
         return FROM_DECLARATION_ANNOTATIONS_ONLY.isNullable(param)
-            || containsNullable(param.getAnnotatedType().getAnnotations())
-            || isNullableTypeVariable(param.getAnnotatedType().getType());
-      }
-
-      @IgnoreJRERequirement
-      boolean isNullableTypeVariable(Type type) {
-        if (!(type instanceof TypeVariable)) {
-          return false;
-        }
-        TypeVariable<?> typeVar = (TypeVariable<?>) type;
-        for (AnnotatedType bound : typeVar.getAnnotatedBounds()) {
-          // Until Java 15, the isNullableTypeVariable case here won't help:
-          // https://bugs.openjdk.java.net/browse/JDK-8202469
-          if (containsNullable(bound.getAnnotations()) || isNullableTypeVariable(bound.getType())) {
-            return true;
-          }
-        }
-        return false;
+        ;
       }
     },
     FROM_DECLARATION_ANNOTATIONS_ONLY {
@@ -663,9 +641,4 @@ boolean isNullable(Parameter param) {
 
     abstract boolean isNullable(Parameter param);
   }
-
-  private static boolean isAndroid() {
-    // Arguably it would make more sense to test "can we see type-use annotations" directly....
-    return checkNotNull(System.getProperty("java.runtime.name", "")).contains("Android");
-  }
 }