feat: implement plugin loader for custom rule plugins

Add implementation for loading custom rule plugins from .so files.
This provides the core functionality needed to dynamically load
and register user-provided rule plugins at runtime.

Changes:
- Created plugin.go with loadCustomRulePlugin and loadCustomRulePlugins functions
- Defined the plugin contract with a fixed function name "AddCustomRules"
- Added comprehensive error handling for plugin loading issues
- Created basic unit tests for the plugin loading functions

The implementation:
- Uses Go's native plugin package for loading shared libraries
- Follows a simple and well-defined contract for plugin authors
- Provides detailed error messages to aid in troubleshooting
- Keeps plugin loading separate from the main CLI flow for better modularity

This is part 2/3 of the plugin system implementation for issue googleapis#1485.
With this change, the api-linter has the core capability to load
plugins, but it still needs to be integrated into the CLI flow.

Author: julioz

cmd/api-linter/plugin.go

@@ -0,0 +1,68 @@
+// Copyright 2025 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// 		https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package main
+
+import (
+	"fmt"
+	"plugin"
+
+	"github.com/googleapis/api-linter/lint"
+)
+
+// addRulesFuncName is the expected name of the function exported by plugins.
+const addRulesFuncName = "AddCustomRules"
+
+// loadCustomRulePlugin loads a plugin from the given path and registers
+// its rules with the provided registry.
+func loadCustomRulePlugin(pluginPath string, registry lint.RuleRegistry) error {
+	// Open the plugin
+	p, err := plugin.Open(pluginPath)
+	if err != nil {
+		return fmt.Errorf("failed to open plugin %q: %v", pluginPath, err)
+	}
+
+	// Look up the AddCustomRules function
+	sym, err := p.Lookup(addRulesFuncName)
+	if err != nil {
+		return fmt.Errorf("plugin %q does not export %q function: %v",
+			pluginPath, addRulesFuncName, err)
+	}
+
+	// Cast to the expected function type
+	addRulesFunc, ok := sym.(func(lint.RuleRegistry) error)
+	if !ok {
+		return fmt.Errorf("plugin %q exports %q with wrong signature",
+			pluginPath, addRulesFuncName)
+	}
+
+	// Call the function to add custom rules
+	if err := addRulesFunc(registry); err != nil {
+		return fmt.Errorf("error registering rules from plugin %q: %v",
+			pluginPath, err)
+	}
+
+	return nil
+}
+
+// loadCustomRulePlugins loads all plugins from the given paths and registers
+// their rules with the provided registry.
+func loadCustomRulePlugins(pluginPaths []string, registry lint.RuleRegistry) error {
+	for _, path := range pluginPaths {
+		if err := loadCustomRulePlugin(path, registry); err != nil {
+			return err
+		}
+	}
+	return nil
+}

cmd/api-linter/plugin_test.go

@@ -0,0 +1,42 @@
+// Copyright 2025 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// 		https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package main
+
+import (
+	"testing"
+
+	"github.com/googleapis/api-linter/lint"
+)
+
+func TestLoadCustomRulePlugins(t *testing.T) {
+	// Mock registry
+	mockRegistry := lint.NewRuleRegistry()
+
+	// Test with empty paths
+	if err := loadCustomRulePlugins(nil, mockRegistry); err != nil {
+		t.Fatalf("loadCustomRulePlugins(nil) = %v; want no error", err)
+	}
+
+	// Test with invalid paths - should return an error
+	invalidPaths := []string{"nonexistent.so"}
+	err := loadCustomRulePlugins(invalidPaths, mockRegistry)
+	if err == nil {
+		t.Fatalf("loadCustomRulePlugins(%v) = nil; want error", invalidPaths)
+	}
+
+	// Note: Testing with actual plugins would require building real .so files,
+	// which is complex to set up in unit tests. In a real integration test,
+	// we would build a test plugin and verify it loads correctly.
+}