Add Generic<'a, T> type alias for generic parameters in _Impl traits

[Copilot]

What's this all about?

This PR implements an improved version of the generics binding improvement from #4155, with the cleaner name Generic instead of ImplParam.

Problem

When implementing generic WinRT interfaces like IMap_Impl<K, V> or IVector_Impl<T>, users had to write Ref<K> for all generic type parameters — even primitives where Ref adds no semantic value:

// Before
impl IMap_Impl<i32, f32> for Map_Impl {
    fn HasKey(&self, key: Ref<i32>) -> Result<bool> { ... }   // unnecessary Ref for i32
    fn Insert(&self, key: Ref<i32>, value: Ref<f32>) -> Result<bool> { ... }
}

The same issue affected event handler closures: TypedEventHandler::new(move |_, args: Ref<i32>| { assert_eq!(*args, 2); }).

Solution

Added a Generic<'a> generic associated type (GAT) to the Type trait in windows-core:

• For CopyType (primitives, GUID, enums, etc.): Generic<'a> = T — the type itself, no Ref wrapper
• For CloneType (HSTRING, etc.): Generic<'a> = Ref<'a, T> — same as before
• For InterfaceType (COM interfaces): Generic<'a> = Ref<'a, T> — same as before

The GAT is named Generic<'a> to avoid confusion with the existing Param trait.

A public type alias is exported:

pub type Generic<'a, T> = <T as Type<T>>::Generic<'a>;

A #[doc(hidden)] free function generic_as_default is exported from windows_core to convert a Generic<'_, T> reference to a &T::Default reference. This is needed by generic collection implementations (IMap_Impl, IVector_Impl, etc.) because Generic<'_, T> is either T itself (for CopyType) or Ref<'_, T> (for other types), and there is no built-in Rust construct that dereferences uniformly across both forms. The function is a zero-cost reinterpretation since Generic<'_, T> and T::Default always share the same memory layout. Generated vtable code uses core::mem::transmute_copy directly instead of a trait helper method.

Result

Users can now write generic type parameters directly for primitives:

// After
impl IMap_Impl<i32, f32> for Map_Impl {
    fn HasKey(&self, key: i32) -> Result<bool> { ... }        // i32 directly!
    fn Insert(&self, key: i32, value: f32) -> Result<bool> { ... }
}

// Event handler closures:
TypedEventHandler::new(move |_, args: i32| { assert_eq!(args, 2); Ok(()) })

For non-primitive types like HSTRING and COM interfaces, Generic<'_, T> resolves to Ref<'_, T> as before.

Changes

• crates/libs/core/src/type.rs — Added Generic<'a> GAT, pub type Generic<'a, T>, and a standalone generic_as_default free function; removed abi_to_generic and generic_as_default trait methods from Type
• crates/libs/bindgen/src/types/method.rs — Updated code generator to emit Generic<'_, T> in _Impl signatures and use core::mem::transmute_copy in vtable upcall code
• Regenerated collections/bindings.rs, future/bindings.rs, Foundation/mod.rs, class_dep.rs, interface_iterable.rs, delegate_generic.rs, reference_custom/bindings.rs, reference_no_deps/bindings.rs
• Updated hand-written collection implementations (map.rs, vector.rs, etc.) to use Generic<'_, T> and the generic_as_default free function
• Updated tests to use primitive types directly and removed TODO comments

[kennykerr]

@copilot might be clearer if this were just called Generic as well otherwise it can be confused with the Param trait.

[Copilot]

Done in 2a23e69. Renamed the GAT from type Param<'a> to type Generic<'a> on the Type trait so it matches the public alias and can't be confused with the Param trait. The pub type Generic<'a, T> alias now resolves to <T as Type<T>>::Generic<'a>.

[kennykerr]

Rename abi_to_param to abi_to_generic.

[Copilot]

Done in f0adad2. Renamed abi_to_param → abi_to_generic throughout.

[kennykerr]

Rename param_as_default to generic_as_default.

[Copilot]

Done in f0adad2. Renamed param_as_default → generic_as_default throughout.

[kennykerr]

@copilot deal with review comments

[kennykerr]

All the generic_as_default implementations appear to be passthroughs - do we really need it?

[Copilot]

Removed from the Type trait in f036bc1. The reason the implementations are all passthroughs is that Generic<'_, T> and T::Default always share the same memory layout (identity for CopyType; Ref<T> is #[repr(transparent)] over T::Abi which is layout-compatible with T::Default for Ref types). The logic is still needed in generic collection code to uniformly convert Generic<'_, K> → &K::Default, so it's now a standalone #[doc(hidden)] free function generic_as_default::<T>(&key) exported from windows_core rather than a trait method.

[kennykerr]

The abi_to_generic doesn't appear to provide any more value over transmute_copy - can we do without?

[Copilot]

Removed in f036bc1. All call sites now use core::mem::transmute_copy directly, and the method is gone from the trait.

[kennykerr]

@copilot deal with review comments

[Copilot]

@copilot deal with review comments

Done in f036bc1. Both abi_to_generic and generic_as_default are removed from the Type trait. abi_to_generic call sites now use core::mem::transmute_copy directly. generic_as_default is kept as a #[doc(hidden)] free function (not a trait method) since the conversion from Generic<'_, T> to &T::Default is still needed in generic collection code.