feat: RDMA multinode GPU support (chain SDK pieces)

Implements the akash-chain-sdk slice of the RDMA spec at
provider/_docs/infiniband-implementation-spec.md, covering Linear tickets
AKT-401..AKT-403, AKT-405, AKT-406 (CS-1, CS-2, CS-3, CS-5, CS-6). The
shared-storage track (CS-4) is intentionally dropped: per spec decision #3
every service gets its own RWO PVC and the provider does not produce
ReadWriteMany volumes.

Everything in this commit is off-chain — no on-chain proto messages change,
no validator upgrade required.

CS-1 — Inventory v1
       (proto/provider/akash/inventory/v1/{node,resources}.proto +
        go/inventory/v1/{node,resources}.pb.go regenerated via `make proto-gen-go`):
  * Add `ResourcePair rdma = 7` to `NodeResources`.
  * Add `rdma_resource_name`, `rdma_fabric`, `nccl_hca_prefix` strings to
    `NodeCapabilities` with gogoproto.customname annotations
    (`RDMAResourceName`, `RDMAFabric`, `NCCLHCAPrefix`).
  * Extend `Dup()` helpers in node.go and resources.go.
  * Tests: `node_test.go`, `resources_test.go` round-trip the new fields
    through Dup().

CS-2 — SDL parser: `gpu.attributes.rdma: true` (go/sdl/gpu.go):
  * Accept `rdma: true|false` under `gpu.attributes`. When true, emit a
    flat on-chain GPU attribute `rdma=true` so providers that advertise
    `capabilities/gpu/rdma=true` match.
  * Tests: `rdma_gpu_test.go::TestV2ResourceGPU_RDMAFlag` plus the existing
    `TestV2ResourceGPU` regression continues to pass.

CS-3 — SDL parser: `gpu.attributes.rdma_group: <name>` →
       off-chain manifest field
       (go/sdl/gpu.go,
        proto/provider/akash/manifest/v2beta3/service.proto regenerated to
        go/manifest/v2beta3/service.pb.go,
        go/sdl/groupBuilder_v2{,_1}.go):
  * Parser captures rdma_group via an internal sentinel attribute key
    (`__rdma_group__`) inside `v2GPUAttributes.UnmarshalYAML`. The parent
    `v2ResourceGPU.UnmarshalYAML` strips the sentinel before the slice ever
    reaches on-chain `Resources.GPU.attributes` and surfaces the value on
    a dedicated `v2ResourceGPU.RDMAGroup` field. `Validate()` is deferred
    to the parent so the sentinel can be removed before the
    attribute-key regex runs.
  * Manifest `Service.proto` gains `rdma_group = 11` with
    `gogoproto.customname = "RDMAGroup"`. Bindings regenerated via
    `make proto-gen-go`.
  * Both v2 / v2.1 group builders now read `compute.Resources.GPU.RDMAGroup`
    and propagate it onto `manifest.Service.RDMAGroup`.
  * Tests: `TestV2ResourceGPU_RDMAGroupRoutedOffChain` (asserts the
    sentinel never escapes) and `TestV2ResourceGPU_RDMAGroupOmitted`.

CS-5 — Parser cross-field validations
       (go/sdl/v2.go, validate() → new validateRDMA()):
  1. Any compute profile with `gpu.attributes.rdma: true` requires its
     placement attributes to include `capabilities/rdma=true`.
  2. Any compute profile with `gpu.attributes.rdma_group` set must also
     declare `gpu.attributes.rdma: true` on the same profile.
  3. Within one placement, no implicit-default-plus-explicit mixing: if
     any profile sets rdma_group, every RDMA-using profile must.
  Helpers `gpuAttributesHaveRDMA` and `placementRequiresRDMA` are kept
  package-local so the SDL parser owns the policy.
  * Tests: `rdma_validation_test.go` (6 positive + negative fixtures).

CS-6 — Reservation commit path audit
       (go/node/deployment/v1beta4/rdma_commit_audit_test.go):
  Table-driven regression test pinning down that `GroupSpec.Dup()` and the
  four concrete `ResourceGroup`-shaped values the provider's reservation
  path can hold (`*Group`, `Group`, `*GroupSpec`, `GroupSpec`) all preserve
  `Requirements.Attributes` (carrying `capabilities/rdma=true`) AND each
  resource's `GPU.Attributes` (carrying `rdma=true`). A future change that
  silently drops either slice — the exact failure mode the spec calls
  out — fails this test loudly.

All `.pb.go` files were regenerated via `make proto-gen-go` (buf v1.47.2,
protoc v29.1, gogoproto v1.7.2). Running `make proto-gen-go` against this
tree should be a no-op.

Tests (go test ./...):
  - pkg.akt.dev/go/inventory/v1                  PASS
  - pkg.akt.dev/go/manifest/v2beta3              PASS
  - pkg.akt.dev/go/node/deployment/v1beta4       PASS (+ new CS-6 audit)
  - pkg.akt.dev/go/sdl                           PASS (+ new CS-2/CS-3/CS-5)

Follow-ups for reviewers:
  - TypeScript bindings (`ts/`) are not touched here and need a separate
    `make proto-gen-ts` pass before the TS SDK consumes the new fields.

Linear: AKT-401, AKT-402, AKT-403, AKT-405, AKT-406
        (AKT-404 / CS-4 cancelled — see spec decision #3)

Fix make/setup-cache.mk: defer GOLANGCI_LINT_MAJOR computation to
recipe-execute time and depend on $(SEMVER), so the install isn't
given an empty major and the broken module path
.../golangci-lint/v/cmd/golangci-lint. This bug had `lint/go` red on
main for several commits prior.

Author: Zblocker64

go/inventory/v1/node.go

@@ -2,7 +2,10 @@ package v1
 
 func (nd *NodeCapabilities) Dup() NodeCapabilities {
 	res := NodeCapabilities{
-		StorageClasses: make([]string, 0, len(nd.StorageClasses)),
+		StorageClasses:   make([]string, 0, len(nd.StorageClasses)),
+		RDMAResourceName: nd.RDMAResourceName,
+		RDMAFabric:       nd.RDMAFabric,
+		NCCLHCAPrefix:    nd.NCCLHCAPrefix,
 	}
 
 	res.StorageClasses = append(res.StorageClasses, nd.StorageClasses...)

go/inventory/v1/node.pb.go

@@ -0,0 +1,42 @@
+package v1
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestNodeCapabilities_Dup_PreservesRDMAFields(t *testing.T) {
+	src := NodeCapabilities{
+		StorageClasses:   []string{"beta3", "default"},
+		RDMAResourceName: "rdma/rdma_shared_device_ib",
+		RDMAFabric:       "infiniband",
+		NCCLHCAPrefix:    "mlx5",
+	}
+
+	got := src.Dup()
+
+	require.Equal(t, src.StorageClasses, got.StorageClasses)
+	require.Equal(t, "rdma/rdma_shared_device_ib", got.RDMAResourceName)
+	require.Equal(t, "infiniband", got.RDMAFabric)
+	require.Equal(t, "mlx5", got.NCCLHCAPrefix)
+
+	// mutating dup must not affect the source (Dup is a deep copy)
+	got.StorageClasses[0] = "mutated"
+	got.RDMAResourceName = "rdma/rdma_shared_device_eth"
+	require.Equal(t, "beta3", src.StorageClasses[0])
+	require.Equal(t, "rdma/rdma_shared_device_ib", src.RDMAResourceName)
+}
+
+func TestNodeCapabilities_Dup_ZeroValueRDMA(t *testing.T) {
+	// A non-RDMA node leaves the new fields at zero value.
+	src := NodeCapabilities{
+		StorageClasses: []string{"default"},
+	}
+
+	got := src.Dup()
+
+	require.Empty(t, got.RDMAResourceName)
+	require.Empty(t, got.RDMAFabric)
+	require.Empty(t, got.NCCLHCAPrefix)
+}

go/inventory/v1/node_test.go

@@ -47,19 +47,43 @@ func (m *ResourcePair) LT(rhs ResourcePair) bool {
 	return m.Allocatable.Cmp(*rhs.Allocatable) == -1
 }
 
+// IsZero reports whether the ResourcePair has been initialized. A
+// zero-valued ResourcePair has nil quantity pointers and is the natural
+// state for, e.g., a node that does not have RDMA capacity (and therefore
+// leaves `NodeResources.RDMA` untouched).
+func (m *ResourcePair) IsZero() bool {
+	if m == nil {
+		return true
+	}
+	return m.Capacity == nil && m.Allocatable == nil && m.Allocated == nil && len(m.Attributes) == 0
+}
+
 func (m *ResourcePair) Dup() ResourcePair {
-	capacity := m.Capacity.DeepCopy()
-	allocatable := m.Allocatable.DeepCopy()
-	allocated := m.Allocated.DeepCopy()
+	// A zero-valued ResourcePair (all quantity pointers nil) must round-trip
+	// through Dup() without panicking. Without this guard, calling Dup()
+	// against e.g. an unpopulated `NodeResources.RDMA` on a non-RDMA node
+	// nil-derefs Capacity.DeepCopy().
+	if m == nil || m.IsZero() {
+		return ResourcePair{}
+	}
 
-	res := ResourcePair{
+	var capacity, allocatable, allocated resource.Quantity
+	if m.Capacity != nil {
+		capacity = m.Capacity.DeepCopy()
+	}
+	if m.Allocatable != nil {
+		allocatable = m.Allocatable.DeepCopy()
+	}
+	if m.Allocated != nil {
+		allocated = m.Allocated.DeepCopy()
+	}
+
+	return ResourcePair{
 		Capacity:    &capacity,
 		Allocatable: &allocatable,
 		Allocated:   &allocated,
 		Attributes:  m.Attributes.Dup(),
 	}
-
-	return res
 }
 
 func (m *ResourcePair) SubMilliNLZ(val types.ResourceValue) bool {