Mark a feature from tessella.h

[jwinarske]

The last of #337.

tessella_result tessella_set_feature_state(tessella_map*, const uint8_t* source, size_t,
                                           const uint8_t* source_layer, size_t,
                                           uint64_t feature_id,
                                           const uint8_t* state_json, size_t);
tessella_result tessella_clear_feature_state(tessella_map*);

Null state is the feature no longer marked, which a host has to be able to say: a feature's state is
replaced whole rather than merged per key, as mbgl's setFeatureState takes it, so a merge could not
remove anything. A state that is not a JSON object answers TESSELLA_BAD_FEATURE_STATE -- an object
is what a style reads keys out of, and an array names nothing.

The map owns the state, not the source

A source is shared by every map on its style and a hover is one map's, so two views of one basemap
highlight independently. That is also what keeps the tile shareable between them: it is built
without state, and stays that way.

So what applies the state is the frame. It re-paints the recorded features of a state-reading layer
as it encodes, from the buffer the bucket was built with -- PaintBinder::restated, the non-mutating
form of what #353 added for exactly this. Nothing is refetched, no tile is rebuilt, and no bucket is
touched.

The re-announce is the existing mechanism

The content stamp gains a fifth term: the host's state revision for the buckets that recorded
features, and zero for every other one -- exactly what pattern_rev beside it does for a sheet
arriving late. A mark therefore re-announces a highlight layer's drawables and leaves the rest of the
cover alone.

Read off the recorded features rather than off the paint, which matters for the layer #353
refuses to index: a highlight that also reads ["within", …] is not re-painted, so it must not be
re-announced either.

What the test asserts

The style has two fill layers over one source -- earth reads state, landuse does not:

• marking feature 1 re-announces, with the camera unmoved;
• it re-announces fewer drawables than the first frame did, which is the layer that reads no
  state not being touched;
• server.requests() does not move, so no tile was rebuilt;
• unmarking is the same shape, which is what makes a hover that moves affordable;
• and a style that reads no state is wholly unaffected by a host that marks features anyway: zero
  re-announces, zero requests.

The fixture's earth layer carries two features and the second's id is 1 -- checked against the
tile with a throwaway probe rather than assumed, after the first version of this test marked an id
that named nothing and passed for the wrong reason.

mutation	caught by
the stamp's state term always zero	no re-announce
the stamp applied to every bucket, not just the indexed ones	both tests -- the plain layer is re-announced too
the revision not bumped on a mark	no re-announce

One thing this test does not do, and says so in its own docs: it does not read the attribute bytes
off the wire. Doing that means resolving a SlabRef through the region's slab table, which is the
consumer's job and is tested as such in web/; my first attempt at it read 96 bytes of zeros and
would have "passed" by comparing nothing with nothing. That the bytes themselves change is
tessella-layout's test, where a restated buffer is compared to a rebuilt one byte for byte.

The cost of the Frame field

Twenty-two files of one line each. Frame is a public struct literal with no default, so every test
that builds one names the new field. A Late bundle for fonts, patterns and state would be the tidier
shape if that ever matters again; I did not reshape it here because the churn is mechanical and the
compiler names every site.

Gate: clippy pinned and stable, rustdoc on default features and all features, the wasm32 check, the
no_std lane, 2282 tests, fmt last, and the pixel gate with probes rebuilt -- the sweep
byte-identical to the last run, zero holes, quad 22 / 22 / 22 / 32 with image_stable 1.

Closes #337