LEP: Unify store get/query/exist interfaces and a define a contract for the store trait

## Problem
`ImmutableStore` had four ways to ask whether a store held an address, each written many times for the store types, and they did not agree. The AWS store resolved the same address two ways and only one of them knew what obliteration was; the replicas sent one request under two names; the remote store downloaded a payload to answer a question about metadata; the composite carried four copies of one fan-out. Nothing said what any of it meant, so each implementation decided for itself, which is why they differed.

## Proposal
Query is unified with exist and becomes a batch interface, responding the best match level found in the store, with a clear contract what the store must uphold in terms of data partitioning.

Both get and metadata reads lose the match level parameter as it was mostly unused and better served by an answer of the best level found - with one `StoreGetData` carrying the fragment, the level and an optional payload, so a caller that loads content learns whether the association was its own.

The store contract is written into the trait and enforced by a battery every store runs: never over-report, may under-report, obliterated never matches, reads do not under-serve and agree with each other, and a match names where it was found.

## Validation
This change also carries the implementation to show what it looks like in practice - the reduced and unified store interface along with the fixes the contract enforcement caught.

```
Imported-PR: #164
Imported-From: 0813eec
Imported-Base: d09b123
Imported-Merge: b83f073
Imported-Author: Mattias Jansson (mjansson)
Signed-off-by: Mattias Jansson <mjansson@gmail.com>
GH-URL: #164
```

Lore-RevId: 555
Lore-Signature: 2acc021e9fee932a40cb45fd89d98db1175bdc3a98380a1cba9e3b78c542f5f7

Author: mjansson

docs/proposals/2026-08-03-fragment-metadata-on-the-s3-object.md

@@ -461,7 +461,7 @@ re-put that sees `MatchFull` and does nothing.
    `error!` turn a silent miss into an alarmable one. *Implemented, on both reads that can observe
    it: `get` and `get_metadata`. Doing it on only one would have made detection depend on which call
    a client happened to make, and `get_metadata` is the cheaper one. The counter is
-   `store.immutable.missing_payload`.*
+   `urc.store.immutable.aws.missing_payload`.*
 
    This is also why a failed `DynamoDB` read must never be reported as not-found. Repair acts on
    that signal, so mapping a throttle to a miss would let overload be recorded as data loss and

docs/proposals/2026-08-04-unify-store-existence-and-metadata.md

@@ -22,6 +22,7 @@ use aws_sdk_s3::operation::list_object_versions::ListObjectVersionsOutput;
 use aws_sdk_s3::operation::put_object::PutObjectError;
 use aws_sdk_s3::operation::put_object::PutObjectOutput;
 use aws_sdk_s3::primitives::ByteStream;
+use bytes::Bytes;
 use lore_telemetry::InstrumentProvider;
 use lore_telemetry::METRICS_OPERATION_LATENCY_METRIC_NAME;
 use lore_telemetry::observe::Observe;
@@ -197,22 +198,22 @@ impl S3Impl {
     /// always observes the metadata that was written with the bytes it is reading. Writing the
     /// two together is what makes them impossible to tear apart.
     #[tracing::instrument(name = "S3Impl::put_object", skip_all)]
-    pub async fn put_object<T>(
+    /// The body is [`Bytes`] rather than something convertible to a `Vec<u8>`: callers already hold
+    /// the payload in a refcounted buffer, and `ByteStream` takes one directly, so the bytes reach
+    /// the SDK without being copied on the way.
+    pub async fn put_object(
         &self,
         bucket: &str,
         key: &str,
-        body: T,
+        body: Bytes,
         metadata: Option<HashMap<String, String>>,
-    ) -> Result<PutObjectOutput, AwsError<SdkError<PutObjectError>>>
-    where
-        T: Into<Vec<u8>> + 'static,
-    {
+    ) -> Result<PutObjectOutput, AwsError<SdkError<PutObjectError>>> {
         self.client
             .put_object()
             .bucket(bucket)
             .key(key)
             .set_metadata(metadata)
-            .body(ByteStream::from(Into::<Vec<u8>>::into(body)))
+            .body(ByteStream::from(body))
             .send()
             .observe(
                 self.instruments.operation_latency_histogram.clone(),