Reflect the latest registry changes in openapi.yaml (#345)

<!-- Provide a brief summary of your changes -->

## Motivation and Context
<!-- Why is this change needed? What problem does it solve? -->
The following PR:
* Adds a new `transport` type used in Package and Remotes
* Added `docker` to the `runtime_hint` examples
* Added support for templated URLs. It is available for streamable-http
and sse transports for Packages. I didn't thought of reasons to have
this for Remotes, but we can enable it if needed.
* Added validation for templated URLs so we can ensure all referenced
placeholder variables are available.
* For streamable-http and SSE transport types the URL is now a required
property
* Updated the publisher init command to reflect these changes
* Updated the seed.json file
* Added unit tests for the transport type related changes
* Updated the server.json schema and the external pkg structs to reflect
the new transport type
* Updated the examples

Thanks to @kkkarthik for spotting it! 🙏 

## How Has This Been Tested?
<!-- Have you tested this in a real application? Which scenarios were
tested? -->
Ran the tests locally

## Breaking Changes
<!-- Will users need to update their code or configurations? -->
Yes

## Types of changes
<!-- What types of changes does your code introduce? Put an `x` in all
the boxes that apply: -->
- [ ] Bug fix (non-breaking change which fixes an issue)
- [ ] New feature (non-breaking change which adds functionality)
- [x] Breaking change (fix or feature that would cause existing
functionality to change)
- [ ] Documentation update

## Checklist
<!-- Go over all the following points, and put an `x` in all the boxes
that apply. -->
- [ ] I have read the [MCP
Documentation](https://modelcontextprotocol.io)
- [ ] My code follows the repository's style guidelines
- [ ] New and existing tests pass locally
- [ ] I have added appropriate error handling
- [ ] I have added or updated documentation as needed

## Additional context
<!-- Add any other context, implementation notes, or design decisions
-->

---------

Signed-off-by: Radoslav Dimitrov <radoslav@stacklok.com>

internal/validators/utils.go

@@ -30,10 +30,51 @@ func HasNoSpaces(s string) bool {
 	return !strings.Contains(s, " ")
 }
 
-// IsValidURL checks if a URL is in valid format
+// extractTemplateVariables extracts template variables from a URL string
+// e.g., "http://{host}:{port}/mcp" returns ["host", "port"]
+func extractTemplateVariables(url string) []string {
+	re := regexp.MustCompile(`\{([^}]+)\}`)
+	matches := re.FindAllStringSubmatch(url, -1)
+	
+	var variables []string
+	for _, match := range matches {
+		if len(match) > 1 {
+			variables = append(variables, match[1])
+		}
+	}
+	return variables
+}
+
+// replaceTemplateVariables replaces template variables with placeholder values for URL validation
+func replaceTemplateVariables(rawURL string) string {
+	// Replace common template variables with valid placeholder values for parsing
+	templateReplacements := map[string]string{
+		"{host}":     "example.com",
+		"{port}":     "8080",
+		"{path}":     "api",
+		"{protocol}": "http",
+		"{scheme}":   "http",
+	}
+	
+	result := rawURL
+	for placeholder, replacement := range templateReplacements {
+		result = strings.ReplaceAll(result, placeholder, replacement)
+	}
+	
+	// Handle any remaining {variable} patterns with generic placeholder
+	re := regexp.MustCompile(`\{[^}]+\}`)
+	result = re.ReplaceAllString(result, "placeholder")
+	
+	return result
+}
+
+// IsValidURL checks if a URL is in valid format (basic structure validation)
 func IsValidURL(rawURL string) bool {
+	// Replace template variables with placeholders for parsing
+	testURL := replaceTemplateVariables(rawURL)
+	
 	// Parse the URL
-	u, err := url.Parse(rawURL)
+	u, err := url.Parse(testURL)
 	if err != nil {
 		return false
 	}
@@ -43,8 +84,67 @@ func IsValidURL(rawURL string) bool {
 		return false
 	}
 
-	if u.Host == "" || u.Hostname() == "localhost" {
+	if u.Host == "" {
 		return false
 	}
 	return true
 }
+
+// IsValidRemoteURL checks if a URL is valid for remotes (stricter than packages - no localhost allowed)
+func IsValidRemoteURL(rawURL string) bool {
+	// First check basic URL structure
+	if !IsValidURL(rawURL) {
+		return false
+	}
+	
+	// Parse the URL to check for localhost restriction
+	u, err := url.Parse(rawURL)
+	if err != nil {
+		return false
+	}
+	
+	// Reject localhost URLs for remotes (security/production concerns)
+	hostname := u.Hostname()
+	if hostname == "localhost" || hostname == "127.0.0.1" || strings.HasSuffix(hostname, ".localhost") {
+		return false
+	}
+	
+	return true
+}
+
+// IsValidTemplatedURL validates a URL with template variables against available variables
+// For packages: validates that template variables reference package arguments or environment variables
+// For remotes: disallows template variables entirely
+func IsValidTemplatedURL(rawURL string, availableVariables []string, allowTemplates bool) bool {
+	// First check basic URL structure
+	if !IsValidURL(rawURL) {
+		return false
+	}
+	
+	// Extract template variables from URL
+	templateVars := extractTemplateVariables(rawURL)
+	
+	// If no templates are found, it's a valid static URL
+	if len(templateVars) == 0 {
+		return true
+	}
+	
+	// If templates are not allowed (e.g., for remotes), reject URLs with templates
+	if !allowTemplates {
+		return false
+	}
+	
+	// Validate that all template variables are available
+	availableSet := make(map[string]bool)
+	for _, v := range availableVariables {
+		availableSet[v] = true
+	}
+	
+	for _, templateVar := range templateVars {
+		if !availableSet[templateVar] {
+			return false
+		}
+	}
+	
+	return true
+}