refactor: remove unused helper functions from models

Removed five unused functions from internal/models/models.go that were
added for generics support but are not currently used:

- HasGenericReceiver() - not called anywhere
- TypeParamMapping() - only used by SubstituteType (also unused)
- TypeParamMappings() - not called anywhere
- getAlternativeTypes() - only used by TypeParamMappings (also unused)
- SubstituteType() - not called anywhere

These functions were implemented for potential future use but are not
needed for current generics functionality. Removing them:
- Reduces maintenance burden
- Improves code coverage (removes 109 uncovered lines)
- Keeps codebase focused on actively used code

All tests continue to pass. Coverage improved as dead code was removed.

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

Co-Authored-By: Claude <noreply@anthropic.com>

Author: cweill

internal/models/models.go

@@ -163,115 +163,6 @@ func (f *Function) IsGeneric() bool {
 	return len(f.TypeParams) > 0
 }
 
-func (f *Function) HasGenericReceiver() bool {
-	return f.Receiver != nil && strings.Contains(f.Receiver.Type.Value, "[")
-}
-
-// TypeParamMapping returns a map from type parameter names to concrete types for testing
-func (f *Function) TypeParamMapping() map[string]string {
-	mapping := make(map[string]string)
-	for _, tp := range f.TypeParams {
-		mapping[tp.Name] = mapConstraintToConcreteType(tp.Constraint)
-	}
-	return mapping
-}
-
-// TypeParamMappings returns multiple mappings for generating tests with different type combinations
-// Returns a slice of mappings, each representing a different concrete instantiation
-func (f *Function) TypeParamMappings() []map[string]string {
-	if !f.IsGeneric() {
-		return nil
-	}
-
-	// For now, generate 2-3 variants per type parameter
-	var allMappings []map[string]string
-
-	// Generate the primary mapping (using defaults)
-	primaryMapping := make(map[string]string)
-	for _, tp := range f.TypeParams {
-		primaryMapping[tp.Name] = mapConstraintToConcreteType(tp.Constraint)
-	}
-	allMappings = append(allMappings, primaryMapping)
-
-	// Generate alternative mappings
-	// For single type parameter, add 1-2 more variants
-	if len(f.TypeParams) == 1 {
-		tp := f.TypeParams[0]
-		alternatives := getAlternativeTypes(tp.Constraint)
-		for _, altType := range alternatives {
-			altMapping := make(map[string]string)
-			altMapping[tp.Name] = altType
-			allMappings = append(allMappings, altMapping)
-		}
-	}
-
-	return allMappings
-}
-
-// getAlternativeTypes returns alternative concrete types for a constraint
-func getAlternativeTypes(constraint string) []string {
-	constraint = strings.TrimSpace(constraint)
-
-	switch {
-	case constraint == "any":
-		return []string{"string"} // Primary is int, alternative is string
-	case constraint == "comparable":
-		return []string{"int"} // Primary is string, alternative is int
-	case strings.Contains(constraint, "|"):
-		// For union types, return other options beyond the first
-		parts := strings.Split(constraint, "|")
-		var alternatives []string
-		for i := 1; i < len(parts) && i < 3; i++ { // Max 2 alternatives
-			alternatives = append(alternatives, strings.TrimSpace(parts[i]))
-		}
-		return alternatives
-	default:
-		return nil
-	}
-}
-
-// mapConstraintToConcreteType maps a constraint to a concrete type
-func mapConstraintToConcreteType(constraint string) string {
-	constraint = strings.TrimSpace(constraint)
-
-	switch {
-	case constraint == "any":
-		return "int"
-	case constraint == "comparable":
-		return "string"
-	case strings.Contains(constraint, "|"):
-		// Union type - pick the first option
-		parts := strings.Split(constraint, "|")
-		return strings.TrimSpace(parts[0])
-	case strings.Contains(constraint, "~"):
-		// Approximation constraint like ~int
-		constraint = strings.TrimPrefix(constraint, "~")
-		return strings.TrimSpace(constraint)
-	default:
-		return "string"
-	}
-}
-
-// SubstituteType replaces type parameter names in a type string with concrete types
-func (f *Function) SubstituteType(typeStr string) string {
-	if !f.IsGeneric() {
-		return typeStr
-	}
-
-	result := typeStr
-	mapping := f.TypeParamMapping()
-
-	// Replace each type parameter with its concrete type
-	// We need to be careful about word boundaries to avoid replacing parts of type names
-	for paramName, concreteType := range mapping {
-		// Simple replacement for now - this handles most cases
-		// More sophisticated parsing would be needed for complex nested types
-		result = strings.ReplaceAll(result, paramName, concreteType)
-	}
-
-	return result
-}
-
 type Import struct {
 	Name, Path string
 }