Fix runtime async in multifile compilation (#122451)

1. When compiling a library, compile all methods including async
variants.
2. When enumerating methods on types, generate variants for every task
returning method, not just virtuals.

The 2 is a bit surprising but it matches what we now do in
https://github.com/dotnet/runtime/blob/d31e5990b896447bfc3dbe98cfe6ec3b169a4896/src/coreclr/tools/Common/JitInterface/CorInfoImpl.cs#L1849-L1857.
We originally restricted this to methods being runtimeasync but changed
it in
https://github.com/dotnet/runtime/pull/121622/files#diff-132a77bcd3f74cf0e0b04fbccda246c97c91e40562d78cb01fff61cf69403573L1860.

Cc @dotnet/ilc-contrib

Author: MichalStrehovsky

src/coreclr/tools/Common/Compiler/CompilerTypeSystemContext.Async.cs

@@ -112,7 +112,7 @@ internal static IEnumerable<MethodDesc> WithAsyncVariants(CompilerTypeSystemCont
             {
                 yield return method;
 
-                // We create an async variant slot for any virtual Task-returning method, not just runtime-async.
+                // We create an async variant slot for any Task-returning method, not just runtime-async.
                 // This is not a problem in practice because the slot is still subject to dependency
                 // analysis and if not used, will not be generated.
                 //
@@ -137,8 +137,14 @@ internal static IEnumerable<MethodDesc> WithAsyncVariants(CompilerTypeSystemCont
                 //     //    didn't know about IFoo in Base either. Who has the slot?
                 //     // A: Base has the runtime-async slot, despite the method not being runtime-async.
                 // }
-                if ((method.IsAsync || method.IsVirtual)
-                    && method.GetTypicalMethodDefinition().Signature.ReturnsTaskOrValueTask())
+                //
+                // The other reason is that when the method is awaited, RyuJIT will prefer the AsyncCallable
+                // variant, no matter if the method is async.
+                //
+                // We restrict this to EcmaMethod since AsyncVariantMethod cannot deal with non-ECMA methods
+                // and we shouldn't be awaiting compiler-generated methods (delegate thunks, etc.) anyway.
+                if (method.GetTypicalMethodDefinition() is EcmaMethod ecmaMethod
+                    && ecmaMethod.Signature.ReturnsTaskOrValueTask())
                 {
                     yield return context.GetAsyncVariantMethod(method);
                 }

src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/LibraryRootProvider.cs

@@ -49,7 +49,7 @@ public void AddCompilationRoots(IRootingServiceProvider rootProvider)
 
         private static void RootMethods(TypeDesc type, string reason, IRootingServiceProvider rootProvider)
         {
-            foreach (MethodDesc method in type.GetAllMethods())
+            foreach (MethodDesc method in type.GetAllMethodsAndAsyncVariants())
             {
                 // Skip methods with no IL and uninstantiated generic methods
                 if (method.IsAbstract || method.HasInstantiation)