Fix thread safety and add compile output caching control

Thread Safety Improvements:
- Replace HashMap with ConcurrentHashMap for thread-safe access
- Implement per-project isolation for attachedResourcesPathsById
- Implement per-project counters to prevent race conditions
- Remove clear() pattern that caused races in multi-threaded builds

Each project now has isolated state (project key → resources map), preventing
cross-module contamination and race conditions in `mvn -T` builds.

Configuration Property:
- Add saveCompileOutputs property (default: true)
- Allows users to control compile-phase caching behavior
- Provides opt-out for users wanting reduced I/O during development
- Default fixes JPMS module descriptor restoration bug

Addresses reviewer feedback on PR apache#394:
1. Thread safety concern with shared HashMap
2. Performance/design concerns about compile-phase caching

Author: cowwoc

src/main/java/org/apache/maven/buildcache/CacheControllerImpl.java

@@ -137,11 +137,17 @@ public class CacheControllerImpl implements CacheController {
     /**
      * A map dedicated to store the base path of resources stored to the cache which are not original artifacts
      * (ex : generated source basedir).
-     * Used to link the resource to its path on disk
+     * Outer map: project key → (classifier → path mapping)
+     * Used to link the resource to its path on disk.
+     * Thread-safe for concurrent access in multi-threaded Maven builds.
      */
-    private final Map<String, Path> attachedResourcesPathsById = new HashMap<>();
+    private final Map<String, Map<String, Path>> attachedResourcesPathsByProject = new ConcurrentHashMap<>();
 
-    private int attachedResourceCounter = 0;
+    /**
+     * Counter for attached resources, isolated per project for thread safety.
+     * Map: project key → counter value
+     */
+    private final Map<String, Integer> attachedResourceCounterByProject = new ConcurrentHashMap<>();
     // CHECKSTYLE_OFF: ParameterNumber
     @Inject
     public CacheControllerImpl(
@@ -498,8 +504,12 @@ public void save(
         final MavenProject project = context.getProject();
         final MavenSession session = context.getSession();
         try {
-            attachedResourcesPathsById.clear();
-            attachedResourceCounter = 0;
+            // Get or create this project's isolated maps for thread safety in multi-threaded builds
+            final String projectKey = getVersionlessProjectKey(project);
+            final Map<String, Path> projectResourcePaths =
+                    attachedResourcesPathsByProject.computeIfAbsent(projectKey, k -> new ConcurrentHashMap<>());
+            // Reset counter for this project (no race condition - each project has its own counter)
+            attachedResourceCounterByProject.put(projectKey, 0);
 
             final HashFactory hashFactory = cacheConfig.getHashFactory();
             final HashAlgorithm algorithm = hashFactory.createAlgorithm();
@@ -641,7 +651,12 @@ private Artifact artifactDto(
             dto.setFileSize(Files.size(file));
 
             // Get the relative path of any extra zip directory added to the cache
-            Path relativePath = attachedResourcesPathsById.get(projectArtifact.getClassifier());
+            final String projectKey = getVersionlessProjectKey(project);
+            final Map<String, Path> projectResourcePaths =
+                    attachedResourcesPathsByProject.get(projectKey);
+            Path relativePath = projectResourcePaths != null
+                    ? projectResourcePaths.get(projectArtifact.getClassifier())
+                    : null;
             if (relativePath == null) {
                 // If the path was not a member of this map, we are in presence of an original artifact.
                 // we get its location on the disk
@@ -946,11 +961,17 @@ private void attachDirIfNotEmpty(
             throws IOException {
         if (Files.isDirectory(candidateSubDir) && hasFiles(candidateSubDir)) {
             final Path relativePath = project.getBasedir().toPath().relativize(candidateSubDir);
-            attachedResourceCounter++;
-            final String classifier = attachedOutputType.getClassifierPrefix() + attachedResourceCounter;
+            // Get this project's isolated counter and map
+            final String projectKey = getVersionlessProjectKey(project);
+            final int counter = attachedResourceCounterByProject.merge(projectKey, 1, Integer::sum);
+            final String classifier = attachedOutputType.getClassifierPrefix() + counter;
             boolean success = zipAndAttachArtifact(project, candidateSubDir, classifier, glob);
             if (success) {
-                attachedResourcesPathsById.put(classifier, relativePath);
+                final Map<String, Path> projectResourcePaths =
+                        attachedResourcesPathsByProject.get(projectKey);
+                if (projectResourcePaths != null) {
+                    projectResourcePaths.put(classifier, relativePath);
+                }
                 LOGGER.debug("Attached directory: {}", candidateSubDir);
             }
         }

src/main/mdo/build-cache-config.mdo

@@ -200,6 +200,12 @@ under the License.
                     <defaultValue>false</defaultValue>
                     <description>Enable the cache storing ability only if a build went through the clean lifecycle.</description>
                 </field>
+                <field>
+                    <name>saveCompileOutputs</name>
+                    <type>boolean</type>
+                    <defaultValue>true</defaultValue>
+                    <description>Enable saving of compile-phase outputs (classes, test-classes, etc.) to cache. When enabled (default), compile-only builds can be cached and restored, fixing JPMS module descriptor restoration issues. Set to false to restore pre-fix behavior and reduce I/O during active development.</description>
+                </field>
                 <field>
                     <name>multiModule</name>
                     <association>