Consolidate return values into `BlobMetadata`. NFC

src/backend.go

···
 	FeatureCheckDomainMarker BackendFeature = "check-domain-marker"
 )
 
+type BlobMetadata struct {
+	Size         int64
+	LastModified time.Time
+}
+
 type GetManifestOptions struct {
 	// If true and the manifest is past the cache `MaxAge`, `GetManifest` blocks and returns
 	// a fresh object instead of revalidating in background and returning a stale object.
···
 
 	// Retrieve a blob. Returns `reader, size, mtime, err`.
 	GetBlob(ctx context.Context, name string) (
-		reader io.ReadSeeker, size uint64, mtime time.Time, err error,
+		reader io.ReadSeeker, metadata BlobMetadata, err error,
 	)
 
 	// Store a blob. If a blob called `name` already exists, this function returns `nil` without

src/backend_fs.go

···
 	"os"
 	"path/filepath"
 	"strings"
-	"time"
 )
 
 type FSBackend struct {
···
 func (fs *FSBackend) GetBlob(
 	ctx context.Context, name string,
 ) (
-	reader io.ReadSeeker, size uint64, mtime time.Time, err error,
+	reader io.ReadSeeker, metadata BlobMetadata, err error,
 ) {
 	blobPath := filepath.Join(splitBlobName(name)...)
 	stat, err := fs.blobRoot.Stat(blobPath)
···
 		err = fmt.Errorf("open: %w", err)
 		return
 	}
-	return file, uint64(stat.Size()), stat.ModTime(), nil
+	return file, BlobMetadata{int64(stat.Size()), stat.ModTime()}, nil
 }
 
 func (fs *FSBackend) PutBlob(ctx context.Context, name string, data []byte) error {

src/backend_s3.go

···
 func (s3 *S3Backend) GetBlob(
 	ctx context.Context, name string,
 ) (
-	reader io.ReadSeeker, size uint64, mtime time.Time, err error,
+	reader io.ReadSeeker, metadata BlobMetadata, err error,
 ) {
 	loader := func(ctx context.Context, name string) (*CachedBlob, error) {
 		logc.Printf(ctx, "s3: get blob %s\n", name)
···
 		}
 	} else {
 		reader = bytes.NewReader(cached.blob)
-		size = uint64(len(cached.blob))
-		mtime = cached.mtime
+		metadata.Size = int64(len(cached.blob))
+		metadata.LastModified = cached.mtime
 	}
 	return
 }

src/collect.go

···
 	"context"
 	"fmt"
 	"io"
-	"time"
 )
 
 type Flusher interface {
···
 
 		case Type_ExternalFile:
 			var blobReader io.Reader
-			var blobMtime time.Time
+			var blobMetadata BlobMetadata
 			var blobData []byte
-			blobReader, _, blobMtime, err = backend.GetBlob(context, string(entry.Data))
+			blobReader, blobMetadata, err = backend.GetBlob(context, string(entry.Data))
+			if err != nil {
+				return
+			}
+			blobData, err = io.ReadAll(blobReader)
 			if err != nil {
 				return
 			}
-			blobData, _ = io.ReadAll(blobReader)
 			header.Typeflag = tar.TypeReg
 			header.Mode = 0644
-			header.ModTime = blobMtime
+			header.ModTime = blobMetadata.LastModified
 			err = appendFile(&header, blobData, entry.GetTransform())
 
 		case Type_Symlink:

src/main.go

···
 			logc.Fatalln(ctx, err)
 		}
 
-		reader, _, _, err := backend.GetBlob(ctx, *getBlob)
+		reader, _, err := backend.GetBlob(ctx, *getBlob)
 		if err != nil {
 			logc.Fatalln(ctx, err)
 		}

src/observe.go

···
 func (backend *observedBackend) GetBlob(
 	ctx context.Context, name string,
 ) (
-	reader io.ReadSeeker, size uint64, mtime time.Time, err error,
+	reader io.ReadSeeker, metadata BlobMetadata, err error,
 ) {
 	span, ctx := ObserveFunction(ctx, "GetBlob", "blob.name", name)
-	if reader, size, mtime, err = backend.inner.GetBlob(ctx, name); err == nil {
-		ObserveData(ctx, "blob.size", size)
+	if reader, metadata, err = backend.inner.GetBlob(ctx, name); err == nil {
+		ObserveData(ctx, "blob.size", metadata.Size)
 		blobsRetrievedCount.Inc()
-		blobsRetrievedBytes.Add(float64(size))
+		blobsRetrievedBytes.Add(float64(metadata.Size))
 	}
 	span.Finish()
 	return

src/pages.go

···
 				w.WriteHeader(http.StatusNotModified)
 				return nil
 			} else {
-				reader, _, mtime, err = backend.GetBlob(r.Context(), string(entry.Data))
+				var metadata BlobMetadata
+				reader, metadata, err = backend.GetBlob(r.Context(), string(entry.Data))
 				if err != nil {
 					ObserveError(err) // all storage errors must be reported
 					w.WriteHeader(http.StatusInternalServerError)
 					fmt.Fprintf(w, "internal server error: %s\n", err)
 					return err
 				}
+				mtime = metadata.LastModified
 				w.Header().Set("ETag", etag)
 			}
 		} else if entry.GetType() == Type_Directory {