Honor ForbidPythonThreadsAttribute when binding methods (fix GC crash)

MethodObject always constructed its binder with allow_threads = true (the
default), ignoring [ForbidPythonThreads]. The per-method check that upstream
performs (MethodObject.AllowThreads) had been dropped, leaving only a
"TODO: ForbidPythonThreadsAttribute per method info" comment.

As a result, methods marked [ForbidPythonThreads] - e.g.
Runtime.TryCollectingGarbage - released the GIL (PythonEngine.BeginAllowThreads)
around their invocation. Calling the CPython C-API without the GIL corrupts the
interpreter, so the very first PyGC_Collect() inside TryCollectingGarbage
faulted with an access violation (0xC0000005), crashing the host. This is why
test_constructors.py::test_constructor_leak aborted the whole pytest run while
a plain Python gc.collect() (GIL held) was fine.

Port the upstream behavior: compute allow_threads from
ForbidPythonThreadsAttribute on the overloads so such methods keep the GIL.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: jhonabreul

src/runtime/Types/MethodObject.cs

@@ -13,9 +13,6 @@ namespace Python.Runtime
     /// Implements a Python type that represents a CLR method. Method objects
     /// support a subscript syntax [] to allow explicit overload selection.
     /// </summary>
-    /// <remarks>
-    /// TODO: ForbidPythonThreadsAttribute per method info
-    /// </remarks>
     [Serializable]
     internal class MethodObject : ExtensionType
     {
@@ -30,7 +27,7 @@ internal class MethodObject : ExtensionType
         internal PyString? doc;
         internal MaybeType type;
 
-        public MethodObject(MaybeType type, string name, List<MethodInformation> info, bool allow_threads = MethodBinder.DefaultAllowThreads)
+        public MethodObject(MaybeType type, string name, List<MethodInformation> info, bool allow_threads)
         {
             this.type = type;
             this.name = name;
@@ -42,6 +39,40 @@ public MethodObject(MaybeType type, string name, List<MethodInformation> info, b
             is_static = info.Any(x => x.MethodBase.IsStatic);
         }
 
+        public MethodObject(MaybeType type, string name, List<MethodInformation> info)
+            : this(type, name, info, allow_threads: AllowThreads(info))
+        {
+        }
+
+        /// <summary>
+        /// Determines whether the Python GIL should be released around invocations
+        /// of these overloads, based on the <see cref="ForbidPythonThreadsAttribute"/>.
+        /// Methods that call back into the CPython C-API (e.g. those marked with the
+        /// attribute) must keep the GIL held; otherwise the call corrupts the
+        /// interpreter / crashes.
+        /// </summary>
+        static bool AllowThreads(List<MethodInformation> methods)
+        {
+            bool hasAllowOverload = false, hasForbidOverload = false;
+            foreach (var method in methods)
+            {
+                bool forbidsThreads = method.MethodBase.GetCustomAttribute<ForbidPythonThreadsAttribute>(inherit: false) != null;
+                if (forbidsThreads)
+                {
+                    hasForbidOverload = true;
+                }
+                else
+                {
+                    hasAllowOverload = true;
+                }
+            }
+
+            if (hasAllowOverload && hasForbidOverload)
+                throw new NotImplementedException("All method overloads currently must either allow or forbid Python threads together");
+
+            return !hasForbidOverload;
+        }
+
         public bool IsInstanceConstructor => name == "__init__";
 
         public MethodObject WithOverloads(List<MethodInformation> overloads)