Add default executionControl reconciliation for common Maven plugins

## Problem
Without executionControl configuration, the build cache does not track critical plugin properties that are often specified via command-line arguments (e.g., -Dmaven.compiler.release). This leads to incorrect cache reuse when these properties change between builds.
In multi-module JPMS projects, this manifests as compilation failures or bytecode version mismatches:
1. Build with `-Dmaven.compiler.release=17` → cache stores Java 17 bytecode (major version 61)
2. Build with `-Dmaven.compiler.release=21` → cache incorrectly reuses Java 17 bytecode
3. Result: Bytecode remains major version 61 instead of expected 65
This is particularly problematic for module-info.class files which are sensitive to Java version.
## Solution
Implemented default reconciliation configs for common plugins when executionControl is not specified:
- **maven-compiler-plugin** (compile & testCompile goals):
  - Tracks `source`, `target`, and `release` properties
  - Ensures cache invalidation when Java version changes
- **maven-install-plugin** (install goal):
  - Tracked to ensure local repository is updated when needed
## Testing
Verified with multi-module JPMS test project:
**Before (broken):**
```
mvn clean verify -Dmaven.compiler.release=17  # Caches Java 17 bytecode
mvn clean verify -Dmaven.compiler.release=21  # Incorrectly reuses Java 17 bytecode
javap -v module-info.class | grep "major version"  # Shows 61 (wrong!)
```
**After (fixed):**
```
mvn clean verify -Dmaven.compiler.release=17  # Caches Java 17 bytecode
mvn clean verify -Dmaven.compiler.release=21  # Detects change, recompiles
javap -v module-info.class | grep "major version"  # Shows 65 (correct!)
```
## Impact
- Users no longer need to manually configure executionControl for basic scenarios
- Prevents silent bytecode version mismatches in JPMS projects
- Backward compatible: explicit executionControl config still takes precedence

Author: cowwoc

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

@@ -248,18 +248,15 @@ public boolean isLogAllProperties(MojoExecution mojoExecution) {
     }
 
     private GoalReconciliation findReconciliationConfig(MojoExecution mojoExecution) {
-        if (cacheConfig.getExecutionControl() == null) {
-            return null;
-        }
+        List<GoalReconciliation> reconciliation;
 
-        final ExecutionControl executionControl = cacheConfig.getExecutionControl();
-        if (executionControl.getReconcile() == null) {
-            return null;
+        if (cacheConfig.getExecutionControl() == null || cacheConfig.getExecutionControl().getReconcile() == null) {
+            // Use default reconciliation configs for common plugins
+            reconciliation = getDefaultReconciliationConfigs();
+        } else {
+            reconciliation = cacheConfig.getExecutionControl().getReconcile().getPlugins();
         }
 
-        final List<GoalReconciliation> reconciliation =
-                executionControl.getReconcile().getPlugins();
-
         for (GoalReconciliation goalReconciliationConfig : reconciliation) {
             final String goal = mojoExecution.getGoal();
 
@@ -271,6 +268,56 @@ private GoalReconciliation findReconciliationConfig(MojoExecution mojoExecution)
         return null;
     }
 
+    private List<GoalReconciliation> getDefaultReconciliationConfigs() {
+        List<GoalReconciliation> defaults = new ArrayList<>();
+
+        // maven-compiler-plugin:compile - track source, target, release
+        GoalReconciliation compilerCompile = new GoalReconciliation();
+        compilerCompile.setArtifactId("maven-compiler-plugin");
+        compilerCompile.setGoal("compile");
+
+        TrackedProperty source = new TrackedProperty();
+        source.setPropertyName("source");
+        compilerCompile.addReconcile(source);
+
+        TrackedProperty target = new TrackedProperty();
+        target.setPropertyName("target");
+        compilerCompile.addReconcile(target);
+
+        TrackedProperty release = new TrackedProperty();
+        release.setPropertyName("release");
+        compilerCompile.addReconcile(release);
+
+        defaults.add(compilerCompile);
+
+        // maven-compiler-plugin:testCompile - track source, target, release
+        GoalReconciliation compilerTestCompile = new GoalReconciliation();
+        compilerTestCompile.setArtifactId("maven-compiler-plugin");
+        compilerTestCompile.setGoal("testCompile");
+
+        TrackedProperty testSource = new TrackedProperty();
+        testSource.setPropertyName("source");
+        compilerTestCompile.addReconcile(testSource);
+
+        TrackedProperty testTarget = new TrackedProperty();
+        testTarget.setPropertyName("target");
+        compilerTestCompile.addReconcile(testTarget);
+
+        TrackedProperty testRelease = new TrackedProperty();
+        testRelease.setPropertyName("release");
+        compilerTestCompile.addReconcile(testRelease);
+
+        defaults.add(compilerTestCompile);
+
+        // maven-install-plugin:install - always run (empty reconciliation means it's tracked)
+        GoalReconciliation install = new GoalReconciliation();
+        install.setArtifactId("maven-install-plugin");
+        install.setGoal("install");
+        defaults.add(install);
+
+        return defaults;
+    }
+
     @Nonnull
     @Override
     public List<PropertyName> getLoggedProperties(MojoExecution mojoExecution) {

src/site/markdown/how-to.md

@@ -160,6 +160,17 @@ Add `executionControl/runAlways` section:
     </executionControl>
 ```
 
+### Default Reconciliation Behavior
+
+The build cache extension automatically tracks certain critical plugin properties by default, even without explicit
+`executionControl` configuration:
+
+* **maven-compiler-plugin** (`compile` and `testCompile` goals): Tracks `source`, `target`, and `release` properties
+* **maven-install-plugin** (`install` goal): Tracked to ensure artifacts are installed when needed
+
+This default behavior prevents common cache invalidation issues, particularly in multi-module JPMS (Java Platform Module System)
+projects where compiler version changes can cause compilation failures.
+
 ### I occasionally cached build with `-DskipTests=true`, and tests do not run now
 
 If you add command line flags to your build, they do not participate in effective pom - Maven defers the final value