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/ipld/go-ipld-prime/node/basicnode/any.go

@@ -0,0 +1,197 @@
+package basicnode
+
+import (
+	"github.com/ipld/go-ipld-prime/datamodel"
+	"github.com/ipld/go-ipld-prime/linking"
+)
+
+var (
+	//_ datamodel.Node          = &anyNode{}
+	_ datamodel.NodePrototype = Prototype__Any{}
+	_ datamodel.NodeBuilder   = &anyBuilder{}
+	//_ datamodel.NodeAssembler = &anyAssembler{}
+)
+
+// Note that we don't use a "var _" declaration to assert that Chooser
+// implements traversal.LinkTargetNodePrototypeChooser, to keep basicnode's
+// dependencies fairly light.
+
+// Chooser implements traversal.LinkTargetNodePrototypeChooser.
+//
+// It can be used directly when loading links into the "any" prototype,
+// or with another chooser layer on top, such as:
+//
+//	prototypeChooser := dagpb.AddSupportToChooser(basicnode.Chooser)
+func Chooser(_ datamodel.Link, _ linking.LinkContext) (datamodel.NodePrototype, error) {
+	return Prototype.Any, nil
+}
+
+// -- Node interface methods -->
+
+// Unimplemented at present -- see "REVIEW" comment on anyNode.
+
+// -- NodePrototype -->
+
+type Prototype__Any struct{}
+
+func (Prototype__Any) NewBuilder() datamodel.NodeBuilder {
+	return &anyBuilder{}
+}
+
+// -- NodeBuilder -->
+
+// anyBuilder is a builder for any kind of node.
+//
+// anyBuilder is a little unusual in its internal workings:
+// unlike most builders, it doesn't embed the corresponding assembler,
+// nor will it end up using anyNode,
+// but instead embeds a builder for each of the kinds it might contain.
+// This is because we want a more granular return at the end:
+// if we used anyNode, and returned a pointer to just the relevant part of it,
+// we'd have all the extra bytes of anyNode still reachable in GC terms
+// for as long as that handle to the interior of it remains live.
+type anyBuilder struct {
+	// kind is set on first interaction, and used to select which builder to delegate 'Build' to!
+	// As soon as it's been set to a value other than zero (being "Invalid"), all other Assign/Begin calls will fail since something is already in progress.
+	// May also be set to the magic value '99', which means "i dunno, I'm just carrying another node of unknown prototype".
+	kind datamodel.Kind
+
+	// Only one of the following ends up being used...
+	//  but we don't know in advance which one, so all are embeded here.
+	//   This uses excessive space, but amortizes allocations, and all will be
+	//    freed as soon as the builder is done.
+	// Builders are only used for recursives;
+	//  scalars are simple enough we just do them directly.
+	// 'scalarNode' may also hold another Node of unknown prototype (possibly not even from this package),
+	//  in which case this is indicated by 'kind==99'.
+
+	mapBuilder  plainMap__Builder
+	listBuilder plainList__Builder
+	scalarNode  datamodel.Node
+}
+
+func (nb *anyBuilder) Reset() {
+	*nb = anyBuilder{}
+}
+
+func (nb *anyBuilder) BeginMap(sizeHint int64) (datamodel.MapAssembler, error) {
+	if nb.kind != datamodel.Kind_Invalid {
+		panic("misuse")
+	}
+	nb.kind = datamodel.Kind_Map
+	nb.mapBuilder.w = &plainMap{}
+	return nb.mapBuilder.BeginMap(sizeHint)
+}
+func (nb *anyBuilder) BeginList(sizeHint int64) (datamodel.ListAssembler, error) {
+	if nb.kind != datamodel.Kind_Invalid {
+		panic("misuse")
+	}
+	nb.kind = datamodel.Kind_List
+	nb.listBuilder.w = &plainList{}
+	return nb.listBuilder.BeginList(sizeHint)
+}
+func (nb *anyBuilder) AssignNull() error {
+	if nb.kind != datamodel.Kind_Invalid {
+		panic("misuse")
+	}
+	nb.kind = datamodel.Kind_Null
+	return nil
+}
+func (nb *anyBuilder) AssignBool(v bool) error {
+	if nb.kind != datamodel.Kind_Invalid {
+		panic("misuse")
+	}
+	nb.kind = datamodel.Kind_Bool
+	nb.scalarNode = NewBool(v)
+	return nil
+}
+func (nb *anyBuilder) AssignInt(v int64) error {
+	if nb.kind != datamodel.Kind_Invalid {
+		panic("misuse")
+	}
+	nb.kind = datamodel.Kind_Int
+	nb.scalarNode = NewInt(v)
+	return nil
+}
+func (nb *anyBuilder) AssignFloat(v float64) error {
+	if nb.kind != datamodel.Kind_Invalid {
+		panic("misuse")
+	}
+	nb.kind = datamodel.Kind_Float
+	nb.scalarNode = NewFloat(v)
+	return nil
+}
+func (nb *anyBuilder) AssignString(v string) error {
+	if nb.kind != datamodel.Kind_Invalid {
+		panic("misuse")
+	}
+	nb.kind = datamodel.Kind_String
+	nb.scalarNode = NewString(v)
+	return nil
+}
+func (nb *anyBuilder) AssignBytes(v []byte) error {
+	if nb.kind != datamodel.Kind_Invalid {
+		panic("misuse")
+	}
+	nb.kind = datamodel.Kind_Bytes
+	nb.scalarNode = NewBytes(v)
+	return nil
+}
+func (nb *anyBuilder) AssignLink(v datamodel.Link) error {
+	if nb.kind != datamodel.Kind_Invalid {
+		panic("misuse")
+	}
+	nb.kind = datamodel.Kind_Link
+	nb.scalarNode = NewLink(v)
+	return nil
+}
+func (nb *anyBuilder) AssignNode(v datamodel.Node) error {
+	if nb.kind != datamodel.Kind_Invalid {
+		panic("misuse")
+	}
+	nb.kind = 99
+	nb.scalarNode = v
+	return nil
+}
+func (anyBuilder) Prototype() datamodel.NodePrototype {
+	return Prototype.Any
+}
+
+func (nb *anyBuilder) Build() datamodel.Node {
+	switch nb.kind {
+	case datamodel.Kind_Invalid:
+		panic("misuse")
+	case datamodel.Kind_Map:
+		return nb.mapBuilder.Build()
+	case datamodel.Kind_List:
+		return nb.listBuilder.Build()
+	case datamodel.Kind_Null:
+		return datamodel.Null
+	case datamodel.Kind_Bool:
+		return nb.scalarNode
+	case datamodel.Kind_Int:
+		return nb.scalarNode
+	case datamodel.Kind_Float:
+		return nb.scalarNode
+	case datamodel.Kind_String:
+		return nb.scalarNode
+	case datamodel.Kind_Bytes:
+		return nb.scalarNode
+	case datamodel.Kind_Link:
+		return nb.scalarNode
+	case 99:
+		return nb.scalarNode
+	default:
+		panic("unreachable")
+	}
+}
+
+// -- NodeAssembler -->
+
+// ... oddly enough, we seem to be able to put off implementing this
+//  until we also implement something that goes full-hog on amortization
+//   and actually has a slab of `anyNode`.  Which so far, nothing does.
+//    See "REVIEW" comment on anyNode.
+// type anyAssembler struct {
+// 	w *anyNode
+// }