Integrate BACKBEAT SDK and resolve KACHING license validation

Major integrations and fixes:
- Added BACKBEAT SDK integration for P2P operation timing
- Implemented beat-aware status tracking for distributed operations
- Added Docker secrets support for secure license management
- Resolved KACHING license validation via HTTPS/TLS
- Updated docker-compose configuration for clean stack deployment
- Disabled rollback policies to prevent deployment failures
- Added license credential storage (CHORUS-DEV-MULTI-001)

Technical improvements:
- BACKBEAT P2P operation tracking with phase management
- Enhanced configuration system with file-based secrets
- Improved error handling for license validation
- Clean separation of KACHING and CHORUS deployment stacks

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

vendor/github.com/libp2p/go-flow-metrics/registry.go

@@ -0,0 +1,82 @@
+package flow
+
+import (
+	"sync"
+	"time"
+)
+
+// MeterRegistry is a registry for named meters.
+type MeterRegistry struct {
+	meters sync.Map
+}
+
+// Get gets (or creates) a meter by name.
+func (r *MeterRegistry) Get(name string) *Meter {
+	if m, ok := r.meters.Load(name); ok {
+		return m.(*Meter)
+	}
+	m, _ := r.meters.LoadOrStore(name, NewMeter())
+	return m.(*Meter)
+}
+
+// FindIdle finds all meters that haven't been used since the given time.
+func (r *MeterRegistry) FindIdle(since time.Time) []string {
+	var idle []string
+	r.walkIdle(since, func(key interface{}) {
+		idle = append(idle, key.(string))
+	})
+	return idle
+}
+
+// TrimIdle trims that haven't been updated since the given time. Returns the
+// number of timers trimmed.
+func (r *MeterRegistry) TrimIdle(since time.Time) (trimmed int) {
+	// keep these as interfaces to avoid allocating when calling delete.
+	var idle []interface{}
+	r.walkIdle(since, func(key interface{}) {
+		idle = append(idle, since)
+	})
+	for _, i := range idle {
+		r.meters.Delete(i)
+	}
+	return len(idle)
+}
+
+func (r *MeterRegistry) walkIdle(since time.Time, cb func(key interface{})) {
+	// Yes, this is a global lock. However, all taking this does is pause
+	// snapshotting.
+	globalSweeper.snapshotMu.RLock()
+	defer globalSweeper.snapshotMu.RUnlock()
+
+	r.meters.Range(func(k, v interface{}) bool {
+		// So, this _is_ slightly inaccurate.
+		if v.(*Meter).snapshot.LastUpdate.Before(since) {
+			cb(k)
+		}
+		return true
+	})
+}
+
+// Remove removes the named meter from the registry.
+//
+// Note: The only reason to do this is to save a bit of memory. Unused meters
+// don't consume any CPU (after they go idle).
+func (r *MeterRegistry) Remove(name string) {
+	r.meters.Delete(name)
+}
+
+// ForEach calls the passed function for each registered meter.
+func (r *MeterRegistry) ForEach(iterFunc func(string, *Meter)) {
+	r.meters.Range(func(k, v interface{}) bool {
+		iterFunc(k.(string), v.(*Meter))
+		return true
+	})
+}
+
+// Clear removes all meters from the registry.
+func (r *MeterRegistry) Clear() {
+	r.meters.Range(func(k, v interface{}) bool {
+		r.meters.Delete(k)
+		return true
+	})
+}