refactor(blockstore): drop unused Spool methods (PutBlock, Has, Remove)

PutBlock had no callers and *Spool was never consumed as a BlockWriter
(the only implementer of that interface is bucketop.Tx); Has and Remove
had no callers either. Remove all three and the now-unsatisfiable
BlockWriter compile-time assertion, leaving Spool at Path/WriteBlob/
OpenBlob/GetBlock. GetBlock stays because Layered holds the spool as a
BlockReader.

Has/Remove are the spool's eviction primitives and will return with the
spool eviction policy (#26), shaped to what that driver needs.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: frrist

blockstore/spool.go

@@ -21,10 +21,11 @@ import (
 // floor and the read cache — a just-written or hot blob is served straight from
 // disk, skipping the network read tier.
 //
-// Spool is deliberately pure file I/O: it is a blockstore.BlockReader +
-// BlockWriter and nothing more. The lifecycle of a blob (the upload_intents
-// state machine, eviction policy) is owned by the caller that has the registry
-// handle — blockstore cannot import registry without a cycle (registry imports
+// Spool is deliberately pure file I/O: a blockstore.BlockReader plus the
+// streaming BlobReader/BlobWriter, and nothing more. The lifecycle of a blob
+// (the upload_intents state machine, eviction policy) is owned by the caller
+// that has the registry handle — blockstore cannot import registry without a
+// cycle (registry imports
 // blockstore for the segment-metadata types).
 type Spool struct {
 	dir string
@@ -48,32 +49,6 @@ func (s *Spool) Path(digest mh.Multihash) string {
 	return filepath.Join(s.dir, hex.EncodeToString(digest))
 }
 
-// PutBlock writes a raw block to the spool, keyed by its multihash. Writing is
-// atomic (write to a temp file, then rename) so a crash mid-write never leaves a
-// partial blob readable under its digest.
-func (s *Spool) PutBlock(_ context.Context, blk block.Block) error {
-	final := s.Path(blk.Cid().Hash())
-	tmp, err := os.CreateTemp(s.dir, ".tmp-*")
-	if err != nil {
-		return fmt.Errorf("blockstore: spool tempfile: %w", err)
-	}
-	tmpName := tmp.Name()
-	if _, err := tmp.Write(blk.RawData()); err != nil {
-		_ = tmp.Close()
-		_ = os.Remove(tmpName)
-		return fmt.Errorf("blockstore: spool write: %w", err)
-	}
-	if err := tmp.Close(); err != nil {
-		_ = os.Remove(tmpName)
-		return fmt.Errorf("blockstore: spool close: %w", err)
-	}
-	if err := os.Rename(tmpName, final); err != nil {
-		_ = os.Remove(tmpName)
-		return fmt.Errorf("blockstore: spool rename: %w", err)
-	}
-	return nil
-}
-
 // WriteBlob streams r to the spool, computing its sha256 digest as it writes so
 // the blob is never held whole in memory (object-body blobs run up to
 // max_blob_size = 256 MiB; buffering them would put that × concurrency in RAM).
@@ -143,26 +118,10 @@ func (s *Spool) GetBlock(_ context.Context, c cid.Cid) (block.Block, error) {
 	return block.NewBlockWithCid(data, c)
 }
 
-// Has reports whether a blob with the given digest is on disk.
-func (s *Spool) Has(digest mh.Multihash) bool {
-	_, err := os.Stat(s.Path(digest))
-	return err == nil
-}
-
-// Remove deletes a spooled blob (eviction / cleanup). Absent files are not an
-// error.
-func (s *Spool) Remove(digest mh.Multihash) error {
-	if err := os.Remove(s.Path(digest)); err != nil && !errors.Is(err, os.ErrNotExist) {
-		return fmt.Errorf("blockstore: spool remove: %w", err)
-	}
-	return nil
-}
-
-// Compile-time assertions: Spool is a read+write block tier, and the streaming
+// Compile-time assertions: Spool is a raw-block read tier and the streaming
 // blob tier for object bodies.
 var (
 	_ BlockReader = (*Spool)(nil)
-	_ BlockWriter = (*Spool)(nil)
 	_ BlobReader  = (*Spool)(nil)
 	_ BlobWriter  = (*Spool)(nil)
 )