Implement auto-tracking of functional parameters from plugin XML definitions

Replace static defaults.xml with dynamic auto-generation that tracks ALL
functional parameters from plugin-parameters/*.xml files.

Changes:
- Remove defaults.xml (no longer needed - all plugins have XML definitions)
- Remove DefaultReconciliationLoader class (replaced by auto-generation)
- Add generateReconciliationFromParameters() method to CacheConfigImpl
  that automatically creates reconciliation configs by reading functional
  parameters from plugin parameter definitions
- Auto-generation runs as final fallback after explicit config check

Benefits:
- Single source of truth (plugin-parameters/*.xml defines everything)
- More comprehensive tracking (all functional params, not just 3)
- Easier maintenance (no need to keep defaults.xml in sync)
- Future-proof (new plugins with XML definitions get auto-tracking)

For maven-compiler-plugin:
- Before: Tracked 3 params (source, target, release)
- After: Tracks ALL 15 functional params (source, target, release,
  encoding, debug, debuglevel, optimize, compilerArgs, etc.)

All existing tests pass, including DefaultReconciliationTest which
validates the auto-generation works correctly.

Addresses reviewer feedback on PR apache#389.

Author: cowwoc

src/main/java/org/apache/maven/buildcache/xml/CacheConfigImpl.java

@@ -119,7 +119,6 @@ public class CacheConfigImpl implements org.apache.maven.buildcache.xml.CacheCon
     private final Provider<MavenSession> providerSession;
     private final RuntimeInformation rtInfo;
     private final PluginParameterLoader parameterLoader;
-    private final DefaultReconciliationLoader defaultReconciliationLoader;
 
     private volatile CacheState state;
     private CacheConfig cacheConfig;
@@ -132,7 +131,6 @@ public CacheConfigImpl(XmlService xmlService, Provider<MavenSession> providerSes
         this.providerSession = providerSession;
         this.rtInfo = rtInfo;
         this.parameterLoader = new PluginParameterLoader();
-        this.defaultReconciliationLoader = new DefaultReconciliationLoader();
     }
 
     @Nonnull
@@ -276,17 +274,16 @@ private GoalReconciliation findReconciliationConfig(MojoExecution mojoExecution)
             }
         }
 
-        // Fall back to defaults if no explicit configuration found
-        List<GoalReconciliation> defaults = getDefaultReconciliationConfigs();
-        for (GoalReconciliation config : defaults) {
-            if (isPluginMatch(plugin, config) && Strings.CS.equals(goal, config.getGoal())) {
-                // Validate default config against parameter definitions (with version)
-                validateReconciliationConfig(config, plugin);
-                return config;
-            }
+        // Auto-generate from parameter definitions (track all functional parameters)
+        GoalReconciliation autoGenerated = generateReconciliationFromParameters(plugin, goal);
+        if (autoGenerated != null) {
+            LOGGER.debug(
+                    "Auto-generated reconciliation config for {}:{} with {} functional parameters",
+                    plugin.getArtifactId(),
+                    goal,
+                    autoGenerated.getReconciles() != null ? autoGenerated.getReconciles().size() : 0);
         }
-
-        return null;
+        return autoGenerated;
     }
 
     /**
@@ -359,83 +356,57 @@ private void validateReconciliationConfig(GoalReconciliation config, Plugin plug
     }
 
     /**
-     * Load default reconciliation configurations from XML.
-     * Defaults are loaded from classpath: default-reconciliation/defaults.xml
+     * Auto-generates a reconciliation config by tracking all functional parameters
+     * from the plugin parameter definition.
+     * This provides automatic default tracking for any plugin with parameter definitions.
+     *
+     * @param plugin The plugin to generate config for
+     * @param goal The goal name
+     * @return Auto-generated config tracking all functional parameters, or null if no parameter definition exists
      */
-    private List<GoalReconciliation> getDefaultReconciliationConfigs() {
-        List<GoalReconciliation> defaults = defaultReconciliationLoader.loadDefaults();
+    private GoalReconciliation generateReconciliationFromParameters(Plugin plugin, String goal) {
+        String artifactId = plugin.getArtifactId();
+        String pluginVersion = plugin.getVersion();
 
-        // Validate all default configurations against parameter definitions
-        validateReconciliationConfigs(defaults);
+        // Load parameter definition for this plugin
+        PluginParameterDefinition pluginDef = parameterLoader.load(artifactId, pluginVersion);
+        if (pluginDef == null) {
+            return null;
+        }
 
-        return defaults;
-    }
+        // Get goal definition
+        PluginParameterDefinition.GoalParameterDefinition goalDef = pluginDef.getGoal(goal);
+        if (goalDef == null) {
+            return null;
+        }
 
-    /**
-     * Validates reconciliation configs against plugin parameter definitions.
-     * Warns about unknown parameters that may indicate plugin changes or configuration errors.
-     */
-    private void validateReconciliationConfigs(List<GoalReconciliation> configs) {
-        for (GoalReconciliation config : configs) {
-            String artifactId = config.getArtifactId();
-            String goal = config.getGoal();
-
-            // Load parameter definition for this plugin
-            PluginParameterDefinition pluginDef = parameterLoader.load(artifactId);
-
-            if (pluginDef == null) {
-                LOGGER.warn(
-                        "No parameter definition found for plugin {}:{}. "
-                                + "Cannot validate reconciliation configuration. "
-                                + "Consider adding a parameter definition file to plugin-parameters/{}.xml",
-                        artifactId,
-                        goal,
-                        artifactId);
-                continue;
+        // Collect all functional parameters
+        List<TrackedProperty> functionalProperties = new ArrayList<>();
+        for (PluginParameterDefinition.ParameterDefinition param : goalDef.getParameters().values()) {
+            if (param.isFunctional()) {
+                TrackedProperty property = new TrackedProperty();
+                property.setPropertyName(param.getName());
+                functionalProperties.add(property);
             }
+        }
 
-            // Get goal definition
-            PluginParameterDefinition.GoalParameterDefinition goalDef = pluginDef.getGoal(goal);
-            if (goalDef == null) {
-                LOGGER.warn(
-                        "Goal '{}' not found in parameter definition for plugin {}. "
-                                + "Cannot validate reconciliation configuration.",
-                        goal,
-                        artifactId);
-                continue;
-            }
+        // Only create config if there are functional parameters to track
+        if (functionalProperties.isEmpty()) {
+            return null;
+        }
 
-            // Validate each tracked property
-            List<TrackedProperty> properties = config.getReconciles();
-            if (properties != null) {
-                for (TrackedProperty property : properties) {
-                    String propertyName = property.getPropertyName();
-
-                    if (!goalDef.hasParameter(propertyName)) {
-                        LOGGER.error(
-                                "Unknown parameter '{}' in default reconciliation config for {}:{}. "
-                                        + "This parameter is not defined in the plugin parameter definition. "
-                                        + "This may indicate a plugin version mismatch or renamed parameter. "
-                                        + "Please update the parameter definition or remove this property from reconciliation.",
-                                propertyName,
-                                artifactId,
-                                goal);
-                    } else {
-                        PluginParameterDefinition.ParameterDefinition paramDef =
-                                goalDef.getParameter(propertyName);
-                        if (paramDef.isBehavioral()) {
-                            LOGGER.warn(
-                                    "Parameter '{}' in reconciliation config for {}:{} is categorized as BEHAVIORAL. "
-                                            + "Behavioral parameters typically should not affect cache invalidation. "
-                                            + "Consider removing this parameter from reconciliation if it doesn't affect build output.",
-                                    propertyName,
-                                    artifactId,
-                                    goal);
-                        }
-                    }
-                }
-            }
+        // Create auto-generated reconciliation config
+        GoalReconciliation config = new GoalReconciliation();
+        config.setArtifactId(artifactId);
+        if (plugin.getGroupId() != null) {
+            config.setGroupId(plugin.getGroupId());
+        }
+        config.setGoal(goal);
+        for (TrackedProperty property : functionalProperties) {
+            config.addReconcile(property);
         }
+
+        return config;
     }
 
     @Nonnull