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/polydawn/refmt/obj/atlas/atlas.go

@@ -0,0 +1,79 @@
+package atlas
+
+import (
+	"fmt"
+	"reflect"
+)
+
+type Atlas struct {
+	// Map typeinfo to a static description of how that type should be handled.
+	// (The internal machinery that will wield this information, and has memory of
+	// progress as it does so, is configured using the AtlasEntry, but allocated separately.
+	// The machinery is stateful and mutable; the AtlasEntry is not.)
+	//
+	// We use 'var rtid uintptr = reflect.ValueOf(rt).Pointer()' -- pointer of the
+	// value of the reflect.Type info -- as an index.
+	// This is both unique and correctly converges when recomputed, and much
+	// faster to compare against than reflect.Type (which is an interface that
+	// tends to contain fairly large structures).
+	mappings map[uintptr]*AtlasEntry
+
+	// Mapping of tag ints to atlasEntry for quick lookups when the
+	// unmarshaller hits a tag.  Values are a subset of `mappings`.
+	tagMappings map[int]*AtlasEntry
+
+	// MapMorphism specifies the default map sorting scheme
+	defaultMapMorphism *MapMorphism
+}
+
+func Build(entries ...*AtlasEntry) (Atlas, error) {
+	atl := Atlas{
+		mappings:           make(map[uintptr]*AtlasEntry),
+		tagMappings:        make(map[int]*AtlasEntry),
+		defaultMapMorphism: &MapMorphism{KeySortMode_Default},
+	}
+	for _, entry := range entries {
+		rtid := reflect.ValueOf(entry.Type).Pointer()
+		if _, exists := atl.mappings[rtid]; exists {
+			return Atlas{}, fmt.Errorf("repeated entry for type %v", entry.Type)
+		}
+		atl.mappings[rtid] = entry
+
+		if entry.Tagged == true {
+			if prev, exists := atl.tagMappings[entry.Tag]; exists {
+				return Atlas{}, fmt.Errorf("repeated tag %v on type %v (already mapped to type %v)", entry.Tag, entry.Type, prev.Type)
+			}
+			atl.tagMappings[entry.Tag] = entry
+		}
+	}
+	return atl, nil
+}
+func MustBuild(entries ...*AtlasEntry) Atlas {
+	atl, err := Build(entries...)
+	if err != nil {
+		panic(err)
+	}
+	return atl
+}
+
+func (atl Atlas) WithMapMorphism(m MapMorphism) Atlas {
+	atl.defaultMapMorphism = &m
+	return atl
+}
+
+// Gets the AtlasEntry for a typeID.  Used by obj package, not meant for user facing.
+func (atl Atlas) Get(rtid uintptr) (*AtlasEntry, bool) {
+	ent, ok := atl.mappings[rtid]
+	return ent, ok
+}
+
+// Gets the AtlasEntry for a tag int.  Used by obj package, not meant for user facing.
+func (atl Atlas) GetEntryByTag(tag int) (*AtlasEntry, bool) {
+	ent, ok := atl.tagMappings[tag]
+	return ent, ok
+}
+
+// Gets the default map morphism config.  Used by obj package, not meant for user facing.
+func (atl Atlas) GetDefaultMapMorphism() *MapMorphism {
+	return atl.defaultMapMorphism
+}