[snapshot] new d8 snapshot command

[kkozoriz]

Description

Adds d8 snapshot, a command family for backing up and restoring Deckhouse
workloads without requiring direct connectivity between the source and
destination clusters. A Snapshot CR captures a namespace's manifests and
volume data in-cluster; the CLI can then move that data offline as a plain
directory tree and restore it later into the same or a different
namespace/cluster.

Requires the state-snapshotter and storage-foundation Deckhouse
modules to be enabled on the cluster — the CLI talks to their aggregated
API and DataExport/DataImport CRDs, it doesn't implement snapshotting
itself.

Breaking changes

The pre-existing d8 data export/d8 data import commands are updated to
match storage-foundation's current contract (API group move, an added
finalize step on upload, and a changed expiry signal). This requires a
matching storage-foundation version — clusters on an older one are not
compatible.

Commands

• create — creates a Snapshot object capturing a namespace's state.
  An empty selector captures the whole namespace; --selector limits it to
  matching labels. Reconciled asynchronously by state-snapshotter;
  --wait blocks until it's Ready.
• list — lists Snapshot resources in the cluster.
• describe — shows a snapshot's manifest hierarchy as a tree,
  in-cluster.
• download — downloads a snapshot (manifests + volume data) from the
  cluster into a local directory tree.
• local describe / local get — inspect a downloaded archive's tree
  or get a one-line summary, fully offline.
• import — uploads a downloaded archive into a namespace. Rebuilds
  the tree top-down (parents before children, then manifests, then volume
  data last, since a leaf's DataImport stays pending until its ancestors'
  manifests exist). --node restricts the upload to a single subtree.
• restore — restores a snapshot in-place, into the same namespace it
  came from. Walks the hierarchy node by node, stages and validates the
  whole tree before applying anything. Cross-namespace/cluster restore is
  download + import + restore on the target, not a single command.
• delete — deletes one or more Snapshot objects (by name, by
  --selector, or --all), letting state-snapshotter garbage-collect the
  associated data.

Archive layout

A downloaded snapshot is a plain directory tree, not a single blob —
manifests and volume data live side by side, and child resources nest
recursively:

<root>/
├── snapshot.yaml        # node metadata + checksum of this node's contents
├── manifests/
│   └── <kind>_<name>.yaml
├── data.tar / data.bin  # volume data (filesystem or block), optionally compressed
└── snapshots/           # child nodes, same structure recursively
    └── <kind>_<name>/
        └── ...

Each node is checksummed independently, so downloads/imports can resume
after an interruption without re-verifying the whole tree.

Typical workflow

1. d8 snapshot create — capture a namespace's state in the source cluster.
2. d8 snapshot download — pull manifests + volume data to a local directory.
3. Move the directory wherever it needs to go (offline storage, another
   environment). Inspect it with local describe/local get if needed.
4. d8 snapshot import (into a new/different namespace or cluster) or
   d8 snapshot restore (in place, same namespace).
5. list / describe / delete for day-to-day lifecycle management.

Tests

Unit tests across all new packages, using fake Kubernetes clients and local
HTTP/TLS test servers — no real cluster required. Coverage includes the
download/restore/import pipeline, checksum verification, resumable/chunked
downloads across compression codecs, and the platform-specific archive
safety code that guards against symlink and mount-boundary escapes when
extracting an archive. Concurrency-sensitive packages (pipeline,
volume) are also covered under -race.

Notes

• Builds and passes lint/tests on Linux, macOS, and Windows.
• New dependencies are limited to what the feature needs (CSI snapshot
  client, compression codecs) — no unrelated version bumps.

[Copilot]

Copilot wasn't able to review this pull request because it exceeds the maximum number of lines (20,000). Try reducing the number of changed lines and requesting a review from Copilot again.