Fix #121066: Mark INITCLASS helpers as mutating heap to respect static constructor side-effects (#121069)

## Summary

This PR fixes issue #121066 where JIT optimizations (inlining, CSE, and
redundant branch removal) were not respecting the side-effects of
precise static constructors, leading to incorrect program behavior.

## Problem

The `CORINFO_HELP_INITCLASS` and `CORINFO_HELP_INITINSTCLASS` JIT
helpers were incorrectly marked as `isPure = true` in
`HelperCallProperties::init()`. This caused the JIT to treat these
helpers as having no side effects, allowing optimizations to eliminate
or reorder static constructor calls. However, static constructors can
have observable side effects (modifying static fields, I/O operations,
etc.) that must be preserved.

Consider this reproduction case:

```csharp
class MyPreciseInitClass<T>
{
    static MyPreciseInitClass()
    {
        preciseInitCctorsRun++;  // Side effect!
    }

    public static void TriggerCctorClass() { }
}

// With tiered compilation disabled
MyPreciseInitClass<int>.TriggerCctorClass();
// Expected: preciseInitCctorsRun == 1
// Actual: preciseInitCctorsRun == 0 (constructor was optimized away!)
```

## Changes

**src/coreclr/jit/utils.cpp**
- Removed `isPure = true` for `CORINFO_HELP_INITCLASS` and
`CORINFO_HELP_INITINSTCLASS` cases
- Added `mutatesHeap = true` to properly indicate these helpers modify
program state

**src/tests/JIT/Regression/JitBlue/Runtime_121066/**
- Added regression test that verifies static constructors are invoked
exactly once per generic instantiation
- Test validates the fix by checking that side effects (counter
increments) occur as expected

## Impact

This change ensures that the JIT compiler treats static constructor
initialization helpers as having side effects, preventing incorrect
optimizations that could eliminate or reorder these critical operations.
The performance impact should be minimal since:
1. Static constructors are already guarded by checks in most scenarios
2. The `mayRunCctor` flag was already set (indicating potential side
effects)
3. This primarily affects edge cases with aggressive optimization

Fixes #121066

> [!WARNING]
>
> <details>
> <summary>Firewall rules blocked me from connecting to one or more
addresses (expand for details)</summary>
>
> #### I tried to connect to the following addresses, but was blocked by
firewall rules:
>
> - `https://api.github.com/repos/dotnet/runtime/issues/121066`
>   - Triggering command: `curl -s REDACTED` (http block)
>
> If you need me to access, download, or install something from one of
these locations, you can either:
>
> - Configure [Actions setup
steps](https://gh.io/copilot/actions-setup-steps) to set up my
environment, which run before the firewall is enabled
> - Add the appropriate URLs or hosts to the custom allowlist in this
repository's [Copilot coding agent
settings](https://github.com/dotnet/runtime/settings/copilot/coding_agent)
(admins only)
>
> </details>

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



<details>

<summary>Original prompt</summary>

> Fix #121066 isssue: in jit's
utils.cpp in the function HelperCallProperties::init() find
> ```cpp
>             case CORINFO_HELP_INITCLASS:
>             case CORINFO_HELP_INITINSTCLASS:
> ```
> and remove isPure = true for it and add mutatesHeap = true.
> 
> Also, add the test case for it that was reported in
#121066 (adapt it to be xunit
test), similar to
`src/tests/JIT/Regression/JitBlue/Runtime_120792/Runtime_120792.cs` (but
with the issue id)


</details>



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

💡 You can make Copilot smarter by setting up custom instructions,
customizing its development environment and configuring Model Context
Protocol (MCP) servers. Learn more [Copilot coding agent
tips](https://gh.io/copilot-coding-agent-tips) in the docs.

---------

Co-authored-by: copilot-swe-agent[bot] <[email protected]>
Co-authored-by: EgorBo <[email protected]>

Author: Copilot

src/coreclr/jit/utils.cpp

@@ -1727,7 +1727,7 @@ void HelperCallProperties::init()
 
             case CORINFO_HELP_INITCLASS:
             case CORINFO_HELP_INITINSTCLASS:
-                isPure      = true;
+                mutatesHeap = true;
                 mayRunCctor = true;
                 break;
 

src/tests/JIT/Regression/JitBlue/Runtime_121066/Runtime_121066.cs

@@ -0,0 +1,100 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System;
+using System.Runtime.CompilerServices;
+using Xunit;
+
+public class Runtime_121066
+{
+    public static int preciseInitCctorsRun = 0;
+
+    class MyPreciseInitClass<T>
+    {
+        static MyPreciseInitClass()
+        {
+            preciseInitCctorsRun++;
+        }
+
+        public static void TriggerCctorClass()
+        {
+        }
+
+        public static void TriggerCctorMethod<U>()
+        { }
+    }
+
+    class MyClass<T>
+    {
+        static Type staticVarType = typeof(MyClass<T>);
+        public Type GetTypeOf()
+        {
+            return typeof(MyClass<T>);
+        }
+        public static Type GetTypeOfStatic()
+        {
+            return typeof(MyClass<T>);
+        }
+
+        public static Type GetTypeThroughStaticVar()
+        {
+            return staticVarType;
+        }
+    }
+
+    [Fact]
+    public static void TestEntryPoint()
+    {
+        Assert.True(TestPreciseInitCctors());
+    }
+
+    public static bool TestPreciseInitCctors()
+    {
+        if (preciseInitCctorsRun != 0)
+        {
+            Console.WriteLine("preciseInitCctorsRun should be 0, but is {0}", preciseInitCctorsRun);
+            return false;
+        }
+        MyPreciseInitClass<int>.TriggerCctorClass();
+        if (preciseInitCctorsRun != 1)
+        {
+            Console.WriteLine("preciseInitCctorsRun should be 1, but is {0}", preciseInitCctorsRun);
+            return false;
+        }
+        MyPreciseInitClass<short>.TriggerCctorMethod<int>();
+        if (preciseInitCctorsRun != 2)
+        {
+            Console.WriteLine("TriggerCctorClass should return 2, but is {0}", preciseInitCctorsRun);
+            return false;
+        }
+
+        object o = new MyPreciseInitClass<double>();
+        if (preciseInitCctorsRun != 3)
+        {
+            Console.WriteLine("TriggerCctorClass should return 3, but is {0}", preciseInitCctorsRun);
+            return false;
+        }
+
+        MyPreciseInitClass<object>.TriggerCctorClass();
+        if (preciseInitCctorsRun != 4)
+        {
+            Console.WriteLine("preciseInitCctorsRun should be 4 but is {0}", preciseInitCctorsRun);
+            return false;
+        }
+        MyPreciseInitClass<string>.TriggerCctorMethod<object>();
+        if (preciseInitCctorsRun != 5)
+        {
+            Console.WriteLine("TriggerCctorClass should return 5, but is {0}", preciseInitCctorsRun);
+            return false;
+        }
+
+        o = new MyPreciseInitClass<Type>();
+        if (preciseInitCctorsRun != 6)
+        {
+            Console.WriteLine("TriggerCctorClass should return 6,  but is {0}", preciseInitCctorsRun);
+            return false;
+        }
+
+        return true;
+    }
+}

src/tests/JIT/Regression/JitBlue/Runtime_121066/Runtime_121066.csproj

@@ -0,0 +1,12 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <DebugType>None</DebugType>
+    <Optimize>True</Optimize>
+    <!-- Needed for CLRTestEnvironmentVariable -->
+    <RequiresProcessIsolation>true</RequiresProcessIsolation>
+  </PropertyGroup>
+  <ItemGroup>
+    <Compile Include="$(MSBuildProjectName).cs" />
+    <CLRTestEnvironmentVariable Include="DOTNET_TieredCompilation" Value="0" />
+  </ItemGroup>
+</Project>