test: extend bindgen-test-cases fixture with collision imports

Add deps/a-pkg/types.wit and deps/b-pkg/types.wit to the
bindgen-test-cases WIT fixture. Both define an interface named
"types", creating a name collision that exercises the disambiguation
logic added in the previous commit.

Extend the world to import both packages and add collision host tests
to the existing bindgen_test_cases test module, covering:
- distinct generated record types (collision_types_are_distinct)
- separate host trait impl per colliding interface (collision_host_impl_compiles)

Signed-off-by: James Sturtevant <jsturtevant@gmail.com>

Author: jsturtevant

src/hyperlight_host/tests/wit_test.rs

@@ -487,4 +487,71 @@ mod bindgen_test_cases {
         };
         assert_eq!(result.message, "executed");
     }
+
+    // Verify that the disambiguated types and record types exist
+    // and can be instantiated. This confirms that two interfaces
+    // both named "types" from different packages (a:pkg and b:pkg)
+    // generate distinct trait members (APkgTypes vs BPkgTypes).
+    #[test]
+    fn collision_types_are_distinct() {
+        let info = a::pkg::types::Info {
+            name: String::from("hello"),
+            value: 42,
+        };
+        let detail = b::pkg::types::Detail {
+            label: String::from("world"),
+            count: 99,
+        };
+        assert_eq!(info.name, "hello");
+        assert_eq!(info.value, 42);
+        assert_eq!(detail.label, "world");
+        assert_eq!(detail.count, 99);
+    }
+
+    // Verify the imports trait has distinct associated types for each
+    // colliding interface, ensuring a host implementation can provide
+    // separate implementations for each.
+    struct CollisionHost;
+
+    impl a::pkg::Types for CollisionHost {
+        fn get_info(&mut self) -> a::pkg::types::Info {
+            a::pkg::types::Info {
+                name: String::from("test-info"),
+                value: 1,
+            }
+        }
+    }
+
+    impl b::pkg::Types for CollisionHost {
+        fn get_detail(&mut self) -> b::pkg::types::Detail {
+            b::pkg::types::Detail {
+                label: String::from("test-detail"),
+                count: 2,
+            }
+        }
+    }
+
+    #[allow(refining_impl_trait)]
+    impl test::bindgen_test_cases::BindgenTestCasesImports for CollisionHost {
+        type APkgTypes = Self;
+        fn a_pkg_types(&mut self) -> &mut Self {
+            self
+        }
+        type BPkgTypes = Self;
+        fn b_pkg_types(&mut self) -> &mut Self {
+            self
+        }
+    }
+
+    #[test]
+    fn collision_host_impl_compiles() {
+        // Verifies the generated trait has distinct associated types for each
+        // colliding import. The existence of this test (and the fact it compiles)
+        // is the assertion.
+        let mut host = CollisionHost;
+        let info = a::pkg::Types::get_info(&mut host);
+        assert_eq!(info.name, "test-info");
+        let detail = b::pkg::Types::get_detail(&mut host);
+        assert_eq!(detail.label, "test-detail");
+    }
 }

src/tests/rust_guests/witguest/bindgen-test-cases/deps/a-pkg/types.wit

@@ -0,0 +1,9 @@
+package a:pkg;
+
+interface types {
+    record info {
+        name: string,
+        value: u32,
+    }
+    get-info: func() -> info;
+}

src/tests/rust_guests/witguest/bindgen-test-cases/deps/b-pkg/types.wit

@@ -0,0 +1,9 @@
+package b:pkg;
+
+interface types {
+    record detail {
+        label: string,
+        count: u64,
+    }
+    get-detail: func() -> detail;
+}

src/tests/rust_guests/witguest/bindgen-test-cases/world.wit

@@ -1,6 +1,8 @@
 package test:bindgen-test-cases;
 
 world bindgen-test-cases {
+    import a:pkg/types;
+    import b:pkg/types;
     export executor;
 }