Send the sample transformation chain in mounting order

The chain could not be expressed. A goniometer axis, the Smargon chi/phi and a
grid stage each travelled by a different route - the `goniometer` map, a private
JSON key inside user_data, and `grid_scan` - and nothing said what order they are
mounted in. The order cannot go in the `goniometer` map either: that is a DECTRIS
stream2 field, and RFC 8949 requires deterministic encoders to SORT map keys, so
a map's order is not something a consumer may rely on.

So `transformations` is sent as an ordered ARRAY, base first, each element
carrying name, type, axis vector and angles. The `goniometer` map and `grid_scan`
are still emitted beside it, unchanged, for consumers that only know stream2 -
nothing vendor-defined is mutated, and a stream2 consumer sees exactly what it
saw before.

Smargon chi and phi are ordinary stationary axes that were only ever separate for
historical reasons, and they now appear in the chain like any other. They are
also read back: reader/ had no smargon support at all, so re-opening a file lost
the head position silently. Combined with the earlier change that writes them for
a still rather than only alongside a rotation or a grid scan, the round trip is
now closed.

Metadata version 7. A broker and a writer from different releases must not be
mixed across this: an older writer ignores the chain and reads the unordered map,
so anything whose order matters - a Smargon position, or a grid scan combined
with a rotation - is not reproduced. Said so in docs/CBOR.md and the changelog.

CBORSerialize_Start_Transformations asserts the ORDER survives, not just the
contents, which is the whole point of the array.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

frame_serialize/CBORStream2Serializer.cpp

@@ -358,6 +358,29 @@ inline void CBOR_ENC_GRID_SCAN(CborEncoder &encoder, const char* key, const Grid
     cborErr(cbor_encoder_close_container(&encoder, &mapEncoder));
 }
 
+inline void CBOR_ENC_TRANSFORMATIONS(CborEncoder &encoder, const char* key,
+                                     const std::vector<TransformationAxis> &chain) {
+    if (chain.empty())
+        return;
+
+    CborEncoder arrayEncoder, mapEncoder;
+    cborErr(cbor_encode_text_stringz(&encoder, key));
+    // An ARRAY, not a map: the order is the mounting order and must survive. A CBOR map cannot carry
+    // that - RFC 8949 requires deterministic encoders to sort map keys - which is why this exists
+    // beside the (unordered, DECTRIS-defined) goniometer map rather than replacing it.
+    cborErr(cbor_encoder_create_array(&encoder, &arrayEncoder, chain.size()));
+    for (const auto &axis: chain) {
+        cborErr(cbor_encoder_create_map(&arrayEncoder, &mapEncoder, 5));
+        CBOR_ENC(mapEncoder, "name", axis.name);
+        CBOR_ENC(mapEncoder, "type", axis.rotation ? "rotation" : "translation");
+        CBOR_ENC(mapEncoder, "vector", axis.vector);
+        CBOR_ENC(mapEncoder, "start", static_cast<float>(axis.start));
+        CBOR_ENC(mapEncoder, "increment", static_cast<float>(axis.increment));
+        cborErr(cbor_encoder_close_container(&arrayEncoder, &mapEncoder));
+    }
+    cborErr(cbor_encoder_close_container(&encoder, &arrayEncoder));
+}
+
 inline void CBOR_ENC_GONIOMETER_MAP(CborEncoder &encoder, const char* key, const StartMessage &msg) {
     CborEncoder mapEncoder;
 
@@ -688,7 +711,9 @@ void CBORStream2Serializer::SerializeSequenceStart(const StartMessage& message)
     CBOR_ENC(mapEncoder, "series_id", message.run_number);
     CBOR_ENC(mapEncoder, "fluorescence", message.fluorescence_spectrum);
 
-    // Both, when both are present - the decoder has always read the two keys independently.
+    // The ordered chain, and beside it the DECTRIS-shaped goniometer map and the grid scan, which a
+    // consumer that predates the chain still understands. Both describe the same setup.
+    CBOR_ENC_TRANSFORMATIONS(mapEncoder, "transformations", message.transformations);
     if (message.goniometer)
         CBOR_ENC_GONIOMETER_MAP(mapEncoder, "goniometer", message);
     if (message.grid_scan)