feat: implement full Bazel bzlmod parity features

This commit implements all major features needed for full parity with
Bazel's bzlmod implementation:

**Phase 1: Lockfile Support (P0)**
- Add lockfile/resolution.go with FromResolution() and Compare()
- Compute SHA256 hashes of MODULE.bazel files
- Track yanked versions in lockfile
- Add LockfileMode option (Off, Update, Error, Refresh)

**Phase 2: source.json Parsing (P1)**
- Add local_path source type to registry/types.go
- Add IsLocalPath() method to Source struct
- Add source_test.go with comprehensive tests

**Phase 3: Bazel Compatibility Validation (P1)**
- Add bazel_compat.go with constraint parsing
- Support >=, <=, <, >, - (exclusion) operators
- Add BazelCompatibilityMode option (Off, Warn, Error)
- Validate modules against configured Bazel version

**Phase 4: Vendor Directory Full Implementation (P2)**
- Add registry_vendor.go with vendor registry
- Synthesize metadata from directory structure
- Support local_path source.json for vendored modules
- Chain vendor registry before remote registries

**Phase 5: Registry Mirrors (P2)**
- Parse bazel_registry.json for mirror URLs
- Add fetchWithMirrors() with fallback logic
- Skip 404 errors but try mirrors for server errors

**Phase 6: max_compatibility_level Strategy Enumeration (P3)**
- Add computePossibleResolutionResultsForOneDepSpec()
- Add enumerateStrategies() for cartesian product
- Find all valid versions per DepSpec for MVS

**Phase 7: Multi-Round Nodep Discovery (P3)**
- Add NodepDependencies field to ModuleInfo
- Add IsNodepDep field to Dependency
- Track unfulfilled nodep edges across rounds
- Continue discovery until no new nodeps can be fulfilled

All tests pass. Reference: Bazel bzlmod implementation in
src/main/java/com/google/devtools/build/lib/bazel/bzlmod/

Author: albertocavalcante

bazel_compat.go

@@ -0,0 +1,141 @@
+package gobzlmod
+
+import (
+	"fmt"
+	"regexp"
+	"strconv"
+	"strings"
+
+	"github.com/albertocavalcante/go-bzlmod/selection/version"
+)
+
+// bazelCompatConstraint represents a parsed bazel_compatibility constraint.
+//
+// Reference: ModuleFileGlobals.java lines 213-225
+// See: https://github.com/bazelbuild/bazel/blob/master/src/main/java/com/google/devtools/build/lib/bazel/bzlmod/ModuleFileGlobals.java
+type bazelCompatConstraint struct {
+	operator string // ">=", "<=", ">", "<", "-"
+	version  string // The version part (e.g., "7.0.0")
+}
+
+// bazelCompatConstraintPattern matches bazel_compatibility entries.
+// Format: (>=|<=|>|<|-)X.Y.Z
+var bazelCompatConstraintPattern = regexp.MustCompile(`^(>=|<=|>|<|-)(\d+\.\d+\.\d+)$`)
+
+// parseBazelCompatConstraint parses a bazel_compatibility constraint string.
+func parseBazelCompatConstraint(s string) (*bazelCompatConstraint, error) {
+	match := bazelCompatConstraintPattern.FindStringSubmatch(s)
+	if match == nil {
+		return nil, fmt.Errorf("invalid bazel_compatibility constraint: %q", s)
+	}
+	return &bazelCompatConstraint{
+		operator: match[1],
+		version:  match[2],
+	}, nil
+}
+
+// checkBazelCompatibility checks if the given Bazel version satisfies a constraint.
+//
+// Reference: BazelModuleResolutionFunction.java lines 298-333
+// See: https://github.com/bazelbuild/bazel/blob/master/src/main/java/com/google/devtools/build/lib/bazel/bzlmod/BazelModuleResolutionFunction.java
+func (c *bazelCompatConstraint) check(bazelVersion string) bool {
+	cmp := version.Compare(bazelVersion, c.version)
+
+	switch c.operator {
+	case ">=":
+		return cmp >= 0
+	case "<=":
+		return cmp <= 0
+	case ">":
+		return cmp > 0
+	case "<":
+		return cmp < 0
+	case "-":
+		// Exclusion: the Bazel version must NOT equal the constraint version
+		return cmp != 0
+	default:
+		return false
+	}
+}
+
+// checkBazelCompatibility checks if a Bazel version satisfies all bazel_compatibility constraints.
+// Returns (compatible, reason) where reason explains why it's incompatible.
+//
+// Reference: BazelModuleResolutionFunction.java lines 298-333
+func checkBazelCompatibility(bazelVersion string, constraints []string) (bool, string) {
+	if len(constraints) == 0 {
+		return true, ""
+	}
+
+	if bazelVersion == "" {
+		return true, "" // No Bazel version specified, skip validation
+	}
+
+	// Normalize the Bazel version (strip any prerelease/build metadata for comparison)
+	normalizedBazel := normalizeBazelVersion(bazelVersion)
+
+	var failedConstraints []string
+	for _, constraintStr := range constraints {
+		constraint, err := parseBazelCompatConstraint(constraintStr)
+		if err != nil {
+			// Invalid constraint format, skip it
+			continue
+		}
+
+		if !constraint.check(normalizedBazel) {
+			failedConstraints = append(failedConstraints, constraintStr)
+		}
+	}
+
+	if len(failedConstraints) == 0 {
+		return true, ""
+	}
+
+	// Build explanation
+	if len(failedConstraints) == 1 {
+		return false, fmt.Sprintf("requires %s", failedConstraints[0])
+	}
+	return false, fmt.Sprintf("requires %s", strings.Join(failedConstraints, " and "))
+}
+
+// normalizeBazelVersion strips prerelease and build metadata from a Bazel version.
+// For example, "7.0.0-pre.20231115.1" becomes "7.0.0".
+func normalizeBazelVersion(v string) string {
+	// Find the first hyphen or plus sign
+	if idx := strings.IndexAny(v, "-+"); idx >= 0 {
+		v = v[:idx]
+	}
+
+	// Validate it looks like a version (X.Y.Z)
+	parts := strings.Split(v, ".")
+	if len(parts) >= 3 {
+		// Ensure first 3 parts are numeric
+		for i := 0; i < 3; i++ {
+			if _, err := strconv.Atoi(parts[i]); err != nil {
+				return v // Return original if not valid
+			}
+		}
+		return strings.Join(parts[:3], ".")
+	}
+
+	return v
+}
+
+// checkModuleBazelCompatibility checks all resolved modules for Bazel compatibility
+// and populates the IsBazelIncompatible and BazelIncompatibilityReason fields.
+func checkModuleBazelCompatibility(modules []ModuleToResolve, moduleInfoCache map[string]*ModuleInfo, bazelVersion string) {
+	for i := range modules {
+		m := &modules[i]
+
+		// Get the module's bazel_compatibility constraints from the cache
+		key := m.Name + "@" + m.Version
+		if info, ok := moduleInfoCache[key]; ok && len(info.BazelCompatibility) > 0 {
+			m.BazelCompatibility = info.BazelCompatibility
+			compatible, reason := checkBazelCompatibility(bazelVersion, info.BazelCompatibility)
+			if !compatible {
+				m.IsBazelIncompatible = true
+				m.BazelIncompatibilityReason = reason
+			}
+		}
+	}
+}