fix: add missing imports and correct API usage in documentation

- validating-with-constraints.md.vm: Fixed incorrect API examples
  - Replaced non-existent setConstraintValidationEnabled with correct API
  - Updated to use IBoundLoader.enableFeature() and validateWithConstraints()
  - Replaced custom handler example with FindingCollectingConstraintValidationHandler

- reading-writing-data.md.vm: Added missing imports
  - Added Stream, Files, Path, IOException, UncheckedIOException imports

- executing-metapath.md.vm: Added missing imports
  - Added Map, ConcurrentHashMap imports to MetapathQueryCache example

Author: david-waltermire

src/site/markdown/guides/executing-metapath.md.vm

@@ -212,6 +212,9 @@ try {
 For repeated queries, cache compiled expressions:
 
 ```java
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
 public class MetapathQueryCache {
     private final Map<String, IMetapathExpression> cache =
         new ConcurrentHashMap<>();

src/site/markdown/guides/reading-writing-data.md.vm

@@ -142,6 +142,12 @@ jsonWriter.serialize(catalog, Path.of("catalog.json"));
 ### Batch Conversion
 
 ```java
+import java.io.IOException;
+import java.io.UncheckedIOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.stream.Stream;
+
 public void convertDirectory(Path inputDir, Path outputDir,
         Format inputFormat, Format outputFormat) throws IOException {
 

src/site/markdown/guides/validating-with-constraints.md.vm

@@ -18,31 +18,36 @@ Metaschema constraints provide validation beyond schema compliance:
 ### Validate During Deserialization
 
 ```java
+import dev.metaschema.databind.io.DeserializationFeature;
+import dev.metaschema.databind.io.IBoundLoader;
 import dev.metaschema.oscal.lib.OscalBindingContext;
 import dev.metaschema.oscal.lib.model.Catalog;
-import dev.metaschema.databind.io.Format;
-import dev.metaschema.databind.io.IDeserializer;
-import dev.metaschema.core.model.constraint.IConstraintValidationHandler;
-import dev.metaschema.core.model.validation.IValidationResult;
+
+import java.nio.file.Path;
 
 OscalBindingContext context = OscalBindingContext.instance();
-IDeserializer<Catalog> deserializer = context.newDeserializer(
-    Format.JSON, Catalog.class);
+IBoundLoader loader = context.newBoundLoader();
 
-// Enable constraint validation
-deserializer.setConstraintValidationEnabled(true);
+// Enable constraint validation during loading
+loader.enableFeature(DeserializationFeature.DESERIALIZE_VALIDATE_CONSTRAINTS);
 
-Catalog catalog = deserializer.deserialize(Path.of("catalog.json"));
+Catalog catalog = loader.load(Catalog.class, Path.of("catalog.json"));
 ```
 
 ### Validate Existing Objects
 
 ```java
-import dev.metaschema.databind.model.IBoundObject;
 import dev.metaschema.core.model.validation.IValidationResult;
+import dev.metaschema.oscal.lib.OscalBindingContext;
+
+import java.net.URI;
+import java.nio.file.Path;
+
+OscalBindingContext context = OscalBindingContext.instance();
+URI target = Path.of("catalog.json").toUri();
 
-// Validate an already-loaded object
-IValidationResult result = context.validate(catalog);
+// Validate against constraints
+IValidationResult result = context.validateWithConstraints(target, null);
 
 if (!result.isPassing()) {
     result.getFindings().forEach(finding -> {
@@ -55,10 +60,18 @@ if (!result.isPassing()) {
 ## Working with Validation Results
 
 ```java
+import dev.metaschema.core.model.constraint.IConstraint.Level;
 import dev.metaschema.core.model.validation.IValidationFinding;
 import dev.metaschema.core.model.validation.IValidationResult;
+import dev.metaschema.oscal.lib.OscalBindingContext;
+
+import java.net.URI;
+import java.nio.file.Path;
 
-IValidationResult result = context.validate(catalog);
+OscalBindingContext context = OscalBindingContext.instance();
+URI target = Path.of("catalog.json").toUri();
+
+IValidationResult result = context.validateWithConstraints(target, null);
 
 // Check if validation passed
 if (result.isPassing()) {
@@ -85,34 +98,30 @@ for (IValidationFinding finding : result.getFindings()) {
 | `WARNING` | Potential issue, may be intentional |
 | `INFORMATIONAL` | Note for awareness |
 
-## Custom Validation Handler
+## Using FindingCollectingConstraintValidationHandler
 
-```java
-import dev.metaschema.core.model.constraint.IConstraintValidationHandler;
-import dev.metaschema.core.model.constraint.IFinding;
+The framework provides `FindingCollectingConstraintValidationHandler` for collecting validation findings:
 
-public class CustomValidationHandler implements IConstraintValidationHandler {
-
-    private final List<IFinding> findings = new ArrayList<>();
-
-    @Override
-    public void handleFinding(IFinding finding) {
-        findings.add(finding);
+```java
+import dev.metaschema.core.model.constraint.FindingCollectingConstraintValidationHandler;
+import dev.metaschema.core.model.constraint.IConstraint.Level;
 
-        // Log immediately
-        if (finding.getSeverity().ordinal() >= Severity.ERROR.ordinal()) {
-            System.err.println("Validation error: " + finding.getMessage());
-        }
-    }
+// The handler implements IValidationResult
+FindingCollectingConstraintValidationHandler handler =
+    new FindingCollectingConstraintValidationHandler();
 
-    public List<IFinding> getFindings() {
-        return findings;
-    }
+// After validation completes, check results
+if (!handler.isPassing()) {
+    handler.getFindings().forEach(finding -> {
+        System.err.println(finding.getSeverity() + ": " +
+            finding.getMessage());
+    });
+}
 
-    public boolean hasErrors() {
-        return findings.stream()
-            .anyMatch(f -> f.getSeverity().ordinal() >= Severity.ERROR.ordinal());
-    }
+// Check highest severity level
+Level highestSeverity = handler.getHighestSeverity();
+if (highestSeverity.ordinal() >= Level.ERROR.ordinal()) {
+    System.err.println("Validation failed with errors");
 }
 ```