Render overload hint in snake_case (method and parameter names)

The "No method matches" hint now uses the snake_case names Python callers
actually use, both in the message header and in each candidate signature:

    No method matches given arguments for compute_scaled: (<class 'float'>). The expected signature is:
      compute_scaled(Int32 scale_factor)

- Add SnakeCaseName(MethodBase) and use it for the header and FormatSignature
  (constructors keep their special .ctor token).
- Snake_case parameter names in FormatSignature via Name.ToSnakeCase().
- Add tests: method name and parameter names are snake_cased for single and
  multiple overloads.

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

Author: jhonabreul

src/embed_tests/TestFloatToIntConversion.cs

@@ -32,6 +32,15 @@ def overloaded_ctor(value):
 
 def overloaded_method(value):
     return OverloadedIntTaker(0).Echo(value)
+
+def single_named(value):
+    return IntTaker(0).ComputeValue(value)
+
+def overloaded_named(value):
+    return OverloadedIntTaker(0).ComputeRange(value)
+
+def single_params(value):
+    return IntTaker(0).ComputeScaled(value)
 ";
 
         [OneTimeSetUp]
@@ -95,6 +104,33 @@ public void ErrorMessage_MultipleOverloads_ListsCandidates()
             // The int overload is surfaced, hinting an integer was expected.
             StringAssert.Contains("Int32 range", ex.Message);
         }
+
+        // The hinted signatures use the snake_case name Python callers use, not the
+        // original C# name.
+        [Test]
+        public void ErrorMessage_SingleOverload_UsesSnakeCaseMethodName()
+        {
+            var ex = Assert.Throws<PythonException>(() => Call("single_named", 5.5));
+            StringAssert.Contains("compute_value(", ex.Message);
+            StringAssert.DoesNotContain("ComputeValue", ex.Message);
+        }
+
+        [Test]
+        public void ErrorMessage_MultipleOverloads_UseSnakeCaseMethodName()
+        {
+            var ex = Assert.Throws<PythonException>(() => Call("overloaded_named", 5.5));
+            StringAssert.Contains("compute_range(", ex.Message);
+            StringAssert.DoesNotContain("ComputeRange", ex.Message);
+        }
+
+        // The hinted signatures also snake_case the parameter names.
+        [Test]
+        public void ErrorMessage_SignatureParameters_AreSnakeCase()
+        {
+            var ex = Assert.Throws<PythonException>(() => Call("single_params", 5.5));
+            StringAssert.Contains("scale_factor", ex.Message);
+            StringAssert.DoesNotContain("scaleFactor", ex.Message);
+        }
     }
 
     public class IntTaker
@@ -107,6 +143,10 @@ public IntTaker(int value)
         }
 
         public int Echo(int value) => value;
+
+        public int ComputeValue(int value) => value;
+
+        public int ComputeScaled(int scaleFactor) => scaleFactor;
     }
 
     /// <summary>
@@ -131,5 +171,9 @@ public OverloadedIntTaker(int range, PyObject selector, PyObject volumeSelector
         public int Echo(int value, System.Func<int, int> selector = null) => value;
 
         public int Echo(int value, PyObject selector, PyObject other = null) => value;
+
+        public int ComputeRange(int value, System.Func<int, int> selector = null) => value;
+
+        public int ComputeRange(int value, PyObject selector, PyObject other = null) => value;
     }
 }

src/runtime/MethodBinder.cs

@@ -1006,13 +1006,14 @@ internal virtual NewReference Invoke(BorrowedReference inst, BorrowedReference a
                 if (!Exceptions.ErrorOccurred())
                 {
                     var value = new StringBuilder("No method matches given arguments");
+                    // Use the snake_case name Python callers use, matching the hinted signatures below.
                     if (methodinfo != null && methodinfo.Length > 0)
                     {
-                        value.Append($" for {methodinfo[0].Name}");
+                        value.Append($" for {SnakeCaseName(methodinfo[0])}");
                     }
                     else if (list.Count > 0)
                     {
-                        value.Append($" for {list[0].MethodBase.Name}");
+                        value.Append($" for {SnakeCaseName(list[0].MethodBase)}");
                     }
 
                     value.Append(": ");
@@ -1288,13 +1289,15 @@ private static void AppendOverloads(StringBuilder to, IEnumerable<MethodBase> me
         }
 
         /// <summary>
-        /// Formats a method/constructor as a readable signature, e.g.
-        /// <c>RangeConsolidator(Int32 range, Func[IBaseData, Decimal] selector = None)</c>.
+        /// Formats a method/constructor as a readable signature using the snake_case
+        /// name Python callers use, e.g.
+        /// <c>range_consolidator(Int32 range, Func[IBaseData, Decimal] selector = None)</c>.
+        /// The constructor's special <c>.ctor</c> token is left as-is.
         /// </summary>
         private static string FormatSignature(MethodBase method)
         {
             var to = new StringBuilder();
-            to.Append(method.Name).Append('(');
+            to.Append(SnakeCaseName(method)).Append('(');
             var parameters = method.GetParameters();
             for (var i = 0; i < parameters.Length; i++)
             {
@@ -1307,7 +1310,7 @@ private static string FormatSignature(MethodBase method)
                 {
                     to.Append("params ");
                 }
-                to.Append(FormatType(parameter.ParameterType)).Append(' ').Append(parameter.Name);
+                to.Append(FormatType(parameter.ParameterType)).Append(' ').Append(parameter.Name.ToSnakeCase());
                 if (parameter.IsOptional)
                 {
                     to.Append(" = ").Append(FormatDefaultValue(parameter.DefaultValue));
@@ -1349,6 +1352,15 @@ private static string FormatType(Type type)
             return type.Name;
         }
 
+        /// <summary>
+        /// The snake_case name a Python caller uses for the given method. Constructors
+        /// keep their special <c>.ctor</c> token (a Python caller invokes the type).
+        /// </summary>
+        private static string SnakeCaseName(MethodBase method)
+        {
+            return method.IsConstructor ? method.Name : method.Name.ToSnakeCase();
+        }
+
         private static string FormatDefaultValue(object value)
         {
             if (value == null || value is DBNull)