Use camelCase parameter names in projected struct constructors (#2346)

* Use camelCase parameter names in projected struct constructors

Add a to_camel_case helper (invariant ASCII lowering) and update the
struct constructor codegen to use camelCase parameter names instead of
underscore-prefixed field names. For example, a struct with a 'Stage'
field now generates a constructor parameter named 'stage' rather than
'_Stage', producing a cleaner public API surface.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

* Fall back to underscore prefix for non-PascalCase field names

If the first character of a struct field name is not an uppercase ASCII
letter (e.g. '_Foo'), prepend an underscore instead of lowering, so the
generated parameter name won't collide with the field name.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

* Escape C# keywords and precompute camelCase param names

Address PR review feedback:
- Route camelCase parameter names through write_escaped_identifier so
  that field names like 'Event' or 'Class' produce '@event'/'@Class'
  instead of bare C# keywords.
- Precompute param_name once per field in field_info instead of calling
  to_camel_case twice (parameter list + assignment).

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

* Add missing C# contextual keywords to is_keyword list

Add all 46 contextual keywords from the C# language reference to the
keyword list used by write_escaped_identifier. This ensures generated
identifiers like 'value', 'var', 'dynamic', 'async', 'await', 'record',
'required', 'get', 'set', 'init', 'when', 'where', 'yield', etc. are
properly escaped with '@' when they appear as parameter names.

Reference: https://learn.microsoft.com/dotnet/csharp/language-reference/keywords

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

---------

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: Sergio0694

src/cswinrt/code_writers.h

@@ -674,6 +674,10 @@ namespace cswinrt
 
     bool is_keyword(std::string_view str)
     {
+        // C# reserved keywords (sorted). Contextual keywords (e.g. 'value', 'var',
+        // 'dynamic') are intentionally excluded: they are valid identifiers outside
+        // their specific syntax contexts and do not need '@' escaping.
+        // See: https://learn.microsoft.com/dotnet/csharp/language-reference/keywords
         static constexpr std::string_view keywords[] =
         {
             "abstract",  "as",       "base",     "bool",       "break",     "byte",
@@ -9836,6 +9840,7 @@ R"(
         {
             std::string type;
             std::string name;
+            std::string param_name;
             bool is_interface;
         };
         std::vector fields;
@@ -9845,6 +9850,7 @@ R"(
             field_info field_info{};
             field_info.type = w.write_temp("%", [&](writer& w) { write_projection_type(w, semantics); });
             field_info.name = field.Name();
+            field_info.param_name = to_camel_case(field_info.name);
             if (auto td = std::get_if(&semantics))
             {
                 field_info.is_interface = get_category(*td) == category::interface_type;
@@ -9866,16 +9872,25 @@ R"(
             type.TypeName(),
             type.TypeName());
 
-        // ctor
+        // ctor (use camelCase parameter names for cleaner public API)
         w.write("public %(%)\n{\n%\n}\n",
             type.TypeName(),
             bind_list([](writer& w, auto&& field)
             {
-                w.write("% _%", field.type, field.name);
+                w.write("% %", field.type, bind(field.param_name));
             }, ", ", fields),
             bind_each([](writer& w, auto&& field)
             {
-                w.write("% = _%; ", field.name, field.name);
+                // When the param name matches the field name (i.e. to_camel_case couldn't
+                // change the casing), qualify the field with 'this.' to disambiguate.
+                if (field.name == field.param_name)
+                {
+                    w.write("this.% = %; ", field.name, bind(field.param_name));
+                }
+                else
+                {
+                    w.write("% = %; ", field.name, bind(field.param_name));
+                }
             }, fields));
 
         // properties

src/cswinrt/helpers.h

@@ -13,6 +13,20 @@ namespace cswinrt
         return 0 == value.compare(0, match.size(), match);
     }
 
+    // Converts a PascalCase name to camelCase (lowering the first character).
+    // Uses invariant ASCII lowering to avoid locale-dependent behavior.
+    // If the first character is not an uppercase ASCII letter, the name is
+    // returned unchanged (callers should use 'this.' to disambiguate).
+    static inline std::string to_camel_case(std::string_view const& name)
+    {
+        std::string result(name);
+        if (!result.empty() && result[0] >= 'A' && result[0] <= 'Z')
+        {
+            result[0] = result[0] - 'A' + 'a';
+        }
+        return result;
+    }
+
     static bool is_remove_overload(MethodDef const& method)
     {
         return method.SpecialName() && starts_with(method.Name(), "remove_");