Learning off by default: it makes matching worse on this hardware

Jorijn asked for the control that settles it -- a fresh template, tested with
learning off -- and ran it twice.

  fresh template, 0 folds     30/30, two consecutive blocks of fifteen
  same lineage, 40 folds      12/15
  same lineage, 185 folds     total failure, 108 consecutive rejections

Every one of those measured with learning switched off during the measurement
itself, so nothing moved underneath the numbers, and the fresh-template result is
replicated back to back. Three points, monotonic in fold count.

The mechanism has been visible since the 185-fold collapse: the frames one press
contributes are near-duplicates of a single image from one finger position, so
folding them spends the template's ninety-six slots on that position and evicts
the diversity a twenty-sample enrolment put there. Stock's updates are spread
across many separate presses hours apart, which is where diversity actually comes
from.

And there is nothing on the other side of the scale. A plain enrolment measures
thirty out of thirty, so learning has no headroom to improve anything, and it has
never once been observed to raise a rate under conditions worth defending -- the
run that once looked like proof was confounded by a freshly wiped sensor and a
user learning the technique, both of which Jorijn identified himself while the
numbers were still climbing.

The code stays behind --learn=1. The finding is about this trustlet's algorithm,
not about the idea.

README.md

@@ -109,6 +109,24 @@ the shipped config sets `max_authentication_rescan_times` to 0, because at the
 stock budget a wrong finger never yields a terminal frame and a PAM client
 waits forever for the `verify-no-match` it needs.
 
+**Template learning is implemented and OFF, because it makes matching worse on
+this hardware.** Measured, with learning disabled during each measurement so
+nothing moved underneath the numbers:
+
+| template | folds | rate |
+|---|---|---|
+| fresh 20-sample enrolment | 0 | **30/30** |
+| same lineage, later | 40 | 12/15 |
+| same lineage, later still | 185 | total failure |
+
+The frames one press contributes are near-duplicates of a single image from one
+finger position. Folding them spends the template's 96 slots on that position
+and evicts the diversity the enrolment put there. There is no upside to weigh
+against it either: a plain enrolment already measures 30/30, and learning has
+never once been observed to raise a rate under controlled conditions.
+
+`--learn=1` enables it for experiments. What follows describes how it works.
+
 **Template learning.** Stock rewrites the stored template on every successful
 press — `0x1015 UPDATE_TEMPLATE` while the finger is still down, then a deferred
 `SAVE_DATA` — and the stored body measurably grows over a template's life