re(ui): why rest_plateau is right -- and last is right only for a transient

The shifted keyframe-time reading looked like it implied something
simple: the final pose is reached at a definite time and nothing follows,
so rest should just be the last keyframe and the plateau heuristic could
go. Tested by applying it to EVERY element:

  title              +0.9500 -> +0.6819   -0.2681
  main menu          +0.9460 -> +0.6416   -0.3044
  EXTRAS             +0.9440 -> +0.5745   -0.3695
  publisher splash   +0.9600 -> blank (zero variance, corr undefined)
  developer splash   +0.9643 -> blank

Refuted, and the failure supplies the model. A group is entry -> hold ->
exit, and the exit is the screen's DISMISSAL. While a screen is displayed
it has not reached its last keyframe; it is sitting at the hold. So
rest_plateau is the correct primary rule, and the last keyframe is the
post-exit state -- correct only once the screen is gone, which is why
applying it everywhere blanks the splashes.

This does not contradict the shifted reading. That reading says when each
pose is reached; it says nothing about the group being played to
completion while the screen is still up. The step between them was mine.

And it explains why last wins for the two plateau-less elements: an
element with no hold is a transient, it flashes and is over, and at any
settled moment it is gone -- which is its last keyframe. The draw capture
says the same independently: on the developer splash the _eff glows draw
on frames 94-115 and the logos on 116-211, so the glows are already
finished when the logos are up.

Three independent observables -- animation timing, static composites, and
the per-frame draw log -- now agree on one rule: plateau where there is
one, last keyframe where there is not.

METHOD: a blank render is a NaN correlation, not a low score, and that
NaN was the strongest form of the result; and when a model predicts
something the measurement refuses, suspect the step you supplied between
them.

docs/re/structures/ui-resting-pose.md

@@ -521,3 +521,56 @@ two captures, and it points the same way they do.
 correct results, and `last` still returns an invisible pose 70 % of the time —
 which for a transient element may well be right, and for a persistent one would
 be wrong. The default stays put.
+
+---
+
+## ✅ Why `rest_plateau` is right, and why `last` is right only for a transient
+
+**2026-08-29.** The shifted keyframe-time reading
+([time unit](../ui-keyframe-time-unit.md)) appears to predict something simple:
+the final pose is reached at a definite time and nothing follows, so "rest"
+should just be the last keyframe, with no heuristic at all. Tested
+(`SYLPHEED_REST_RULE=lastall`, bypassing the plateau rule for **every** element):
+
+| screen | current | `lastall` | Δ |
+|---|---|---|---|
+| title | +0.9500 | +0.6819 | **−0.2681** |
+| main menu | +0.9460 | +0.6416 | **−0.3044** |
+| `EXTRAS` | +0.9440 | +0.5745 | **−0.3695** |
+| publisher splash | +0.9600 | **blank** | — |
+| developer splash | +0.9643 | **blank** | — |
+
+The splashes render *entirely empty* — zero variance, so the correlation is not
+even defined. **Refuted.**
+
+### What the failure shows
+
+A group's keyframes describe **entry → hold → exit**, and the exit is the
+screen's *dismissal*. While a screen is on display it has not reached its last
+keyframe; it is sitting at the hold, and the exit plays only when the screen
+leaves. That is why:
+
+* `rest_plateau` is the correct primary rule — the hold is where the screen
+  lives, and it is what a capture of a displayed screen shows;
+* the last keyframe is the **post-exit** state, correct only at the moment the
+  screen is already gone — which is why applying it everywhere blanks the
+  splashes;
+* and it does **not** contradict the shifted time reading. That reading says when
+  each pose is reached; it says nothing about the group being played to
+  completion while the screen is still up.
+
+### And it explains why `last` wins for the plateau-less two
+
+An element with **no hold** is a transient: it flashes and is over. At any
+settled moment it is *gone*, and "gone" is its last keyframe. That is not a
+general rule about rest — it is what a transient's settled state *is*.
+
+The draw capture says exactly this independently: on the developer splash the
+`_eff` glows are drawn on frames **94–115** and the logos on **116–211**. The
+glows are already finished when the logos are up, so a capture of the logo
+moment must show them invisible — which is what `SYLPHEED_REST_RULE=last`
+produces, and why it scored +0.9982 and +0.9758.
+
+✅ So the picture is coherent across three independent observables — animation
+timing, static composites, and the per-frame draw log — and the rule it supports
+is: **plateau where there is one, last keyframe where there is not.**