test: regression test for #1389

Add a minimal test case that reproduces the conditional variable reuse
bug in type initialization.

The test demonstrates:
- A named type (MyType) that is initialized early
- An interface (MyInterface) with a method returning MyType
- The compiler incorrectly reuses the parent type's null check
  condition to control method type initialization

In the generated IR (out.ll):
- Line 163-164: Defines %9 = (MyType == null)
- Line 182: Reuses the same %9 to control InitNamed call
- When MyType already exists, method initialization is skipped

This is the same bug pattern as io/fs.FileMode in the reported issue,
but in a much simpler form for easier understanding and testing.

Related: #1389

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <[email protected]>

Author: luoliwoshang

cl/_testgo/methodinit1389/in.go

@@ -0,0 +1,53 @@
+package main
+
+// This test case reproduces the issue where method type initialization
+// is incorrectly skipped when the parent type is already initialized.
+//
+// The problem occurs when:
+// 1. A named type (MyType) is initialized first (via init or usage)
+// 2. Then an interface (MyInterface) with a method returning MyType needs initialization
+// 3. The compiler incorrectly reuses the null check condition from the parent type
+//    to control method type initialization, causing func() MyType to never be created
+
+// Named type (like io/fs.FileMode)
+type MyType uint32
+
+// Interface with method returning MyType (like io/fs.DirEntry)
+type MyInterface interface {
+	Name() string
+	GetType() MyType // Method returning the named type
+}
+
+// Implementation of MyInterface
+type MyImpl struct {
+	name   string
+	myType MyType
+}
+
+func (m *MyImpl) Name() string {
+	return m.name
+}
+
+func (m *MyImpl) GetType() MyType {
+	return m.myType
+}
+
+// Prematurely initialize MyType by using it in init
+// (simulates the effect of init$after running before dependencies are initialized)
+func init() {
+	_ = MyType(0) // Force MyType to be initialized early
+}
+
+func main() {
+	// Type assertion forces interface type initialization at runtime
+	var i interface{} = &MyImpl{name: "test", myType: 42}
+
+	// This type assertion requires MyInterface type to be fully initialized
+	// including the method type func() MyType
+	if mi, ok := i.(MyInterface); ok {
+		println(mi.Name())
+		println(uint32(mi.GetType()))
+	}
+
+	println("Test passed")
+}