Refactor async calling convention detection to use MethodDesc extension method (#121420)

Consolidates async calling convention detection logic into a single
`MethodDesc` extension method, removing the need for
`MethodSignatureFlags.AsyncCall` flag.

**Changes:**

- **Added `IsAsyncCall` extension method** on `MethodDesc` that unifies
detection logic: returns true for async variants and async intrinsics
that don't return Task/ValueTask
- **Removed `MethodSignatureFlags.AsyncCall`** enum value and
`MethodSignature.IsAsyncCall` property
- **Updated call sites** in `CorInfoImpl.cs` to use the new extension
method for `CORINFO_CALLCONV_ASYNCCALL` and `CORJIT_FLAG_ASYNC`
- **Simplified `AsyncMethodVariant`** to no longer set the AsyncCall
flag in signature

**Rationale:**

Async calling convention is now determined at the MethodDesc level
(similar to hidden parameters in generic calling conventions) rather
than being stored in signature flags. This properly handles both async
variants (which have the flag set by signature transformation) and async
intrinsics (which have `IsAsync` metadata but don't return
Task/ValueTask).

```csharp
// Before: Logic scattered across multiple locations
if (method.IsAsync && !method.Signature.ReturnsTaskOrValueTask())
    sig->callConv |= CorInfoCallConv.CORINFO_CALLCONV_ASYNCCALL;

// After: Unified in extension method
if (method.IsAsyncCall())
    sig->callConv |= CorInfoCallConv.CORINFO_CALLCONV_ASYNCCALL;
```

<!-- START COPILOT CODING AGENT TIPS -->
---

✨ Let Copilot coding agent [set things up for
you](https://github.com/dotnet/runtime/issues/new?title=✨+Set+up+Copilot+instructions&body=Configure%20instructions%20for%20this%20repository%20as%20documented%20in%20%5BBest%20practices%20for%20Copilot%20coding%20agent%20in%20your%20repository%5D%28https://gh.io/copilot-coding-agent-tips%29%2E%0A%0A%3COnboard%20this%20repo%3E&assignees=copilot)
— coding agent works faster and does higher quality work when set up for
your repo.

---------

Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>
Co-authored-by: MichalStrehovsky <13110571+MichalStrehovsky@users.noreply.github.com>

Author: Copilot

src/coreclr/tools/Common/Compiler/AsyncMethodVariant.cs

@@ -34,12 +34,10 @@ public override MethodSignature Signature
         private MethodSignature InitializeSignature()
         {
             var signature = _wrappedMethod.Signature;
-            Debug.Assert(!signature.IsAsyncCall);
             Debug.Assert(signature.ReturnsTaskOrValueTask());
             TypeDesc md = signature.ReturnType;
             MethodSignatureBuilder builder = new MethodSignatureBuilder(signature);
             builder.ReturnType = md.HasInstantiation ? md.Instantiation[0] : this.Context.GetWellKnownType(WellKnownType.Void);
-            builder.Flags = signature.Flags | MethodSignatureFlags.AsyncCall;
             return (_asyncSignature = builder.ToSignature());
         }
 

src/coreclr/tools/Common/Compiler/MethodExtensions.cs

@@ -153,5 +153,12 @@ public static bool ReturnsTaskOrValueTask(this MethodSignature method)
             }
             return false;
         }
+
+        /// <summary>
+        /// Determines whether a method uses the async calling convention.
+        /// Returns true for async variants (compiler-generated wrappers around Task-returning methods)
+        /// and for special async intrinsics that don't return Task/ValueTask but use async calling convention.
+        /// </summary>
+        public static bool IsAsyncCall(this MethodDesc method) => method.IsAsync && (method.IsAsyncVariant() || !method.Signature.ReturnsTaskOrValueTask());
     }
 }

src/coreclr/tools/Common/JitInterface/CorInfoImpl.cs

@@ -833,9 +833,7 @@ private void Get_CORINFO_SIG_INFO(MethodDesc method, CORINFO_SIG_INFO* sig, Meth
         {
             Get_CORINFO_SIG_INFO(method.Signature, sig, scope);
 
-            // Get_CORINFO_SIG_INFO above will have correctly set CORINFO_CALLCONV_ASYNCCALL for async variants,
-            // however the special async intrinsics don't set the async bit in their signature. Compensate for that.
-            if (method.IsAsync && !method.Signature.ReturnsTaskOrValueTask())
+            if (method.IsAsyncCall())
                 sig->callConv |= CorInfoCallConv.CORINFO_CALLCONV_ASYNCCALL;
 
             // Does the method have a hidden parameter?
@@ -882,7 +880,6 @@ private void Get_CORINFO_SIG_INFO(MethodSignature signature, CORINFO_SIG_INFO* s
 
             if (!signature.IsStatic) sig->callConv |= CorInfoCallConv.CORINFO_CALLCONV_HASTHIS;
             if (signature.IsExplicitThis) sig->callConv |= CorInfoCallConv.CORINFO_CALLCONV_EXPLICITTHIS;
-            if (signature.IsAsyncCall) sig->callConv |= CorInfoCallConv.CORINFO_CALLCONV_ASYNCCALL;
 
             TypeDesc returnType = signature.ReturnType;
 
@@ -4337,10 +4334,7 @@ private uint getJitFlags(ref CORJIT_FLAGS flags, uint sizeInBytes)
                 flags.Set(CorJitFlag.CORJIT_FLAG_SOFTFP_ABI);
             }
 
-            // Signature.IsAsyncCall will do the right thing for async variants, however the special async
-            // intrinsics don't set the async bit in their signature. Compensate for that.
-            if (this.MethodBeingCompiled.Signature.IsAsyncCall
-                || (this.MethodBeingCompiled.IsAsync && !this.MethodBeingCompiled.Signature.ReturnsTaskOrValueTask()))
+            if (this.MethodBeingCompiled.IsAsyncCall())
             {
                 flags.Set(CorJitFlag.CORJIT_FLAG_ASYNC);
             }

src/coreclr/tools/Common/TypeSystem/Common/MethodDesc.cs

@@ -23,8 +23,6 @@ public enum MethodSignatureFlags
 
         Static = 0x0010,
         ExplicitThis = 0x0020,
-
-        AsyncCall                            = 0x0100,
     }
 
     public enum EmbeddedSignatureDataKind
@@ -140,14 +138,6 @@ public bool IsExplicitThis
             }
         }
 
-        public bool IsAsyncCall
-        {
-            get
-            {
-                return (_flags & MethodSignatureFlags.AsyncCall) != 0;
-            }
-        }
-
         public int GenericParameterCount
         {
             get