CoordinateAxis.fingerprint: compute when pickling, widen to 64 bits

[cboulay]

Restacked: now based on #268. Adds a commit chaining CoordinateAxis.__getstate__ to super().__getstate__(): with #269 below, ArrayWithNamedDims.__getstate__ exists (it makes strided data contiguous), and returning self.__dict__ bypassed it for coordinate axes (#269's test_coordinate_axis_shares_the_contiguity_fix caught it). Reaching it through the MRO also makes super() safe on Python 3.10.

Stacked on #271.

Why

CoordinateAxis.fingerprint is cached in the instance __dict__, so it already survived pickling, but only if the producer had touched it. A producer that never did shipped its axes without a fingerprint. On the far side of a process boundary every message unpickles into a new axis object, so the first consumer that hashes the axis (e.g. any baseproc BaseStatefulTransformer) recomputed it for every message.

Change

CoordinateAxis.__getstate__ touches self.fingerprint and returns self.__dict__. Pickling (and deepcopy, used for leaky subscribers) now always carries the fingerprint, whichever unit built the axis. Producers no longer need to touch it themselves.

It returns self.__dict__ rather than super().__getstate__() because object.__getstate__ only exists from Python 3.11 and ezmsg still supports 3.10. Worth revisiting once 3.10 is dropped.

Cost

Serializing a (10, 256) float32 message with a 256-label channel axis:

	before	after
reused axis object (typical)	8.7–9.0 µs	8.8 µs
fresh axis object per message	9.5–9.6 µs	10.3 µs

The ~0.7 µs for a per-message axis is the fingerprint computation plus pickling the cached tuple. The first consumer after the hop no longer pays it.

Follow-up

Once this is released, producers that touch .fingerprint at construction (blackrock, simbiophys, orion, parts of lsl/neo/nwb/xdf/sigproc) can stop doing so and leave it lazy: nothing is computed if no unit ever needs it. Touching it at construction saves at most ~1 µs for a small axis, and only when the cache is cold (256 labels: 0.45 µs hot vs 1.39 µs after evicting 64 MiB; 1024 structured records: 5.88 vs 5.96 µs). And when producers reuse their axes, that's per configuration change, not per message.

Tests

test_pickling_computes_it_if_untouched covers plain pickle and MessageMarshal. Full suite: the only failures are the 10 test_settings_json_schema / test_inspect_command failures that also fail on the base branch.

Related: #272, ezmsg-org/ezmsg-baseproc#17.

Also: 64-bit digest

The fingerprint's digest is now (crc32 << 32) | adler32 instead of crc32 alone. A collision used to mean missing one reconfiguration; with #276 the fingerprint also keys axes elided on the wire, where a collision would silently swap one axis's values for another's. crc32 and adler32 are structurally different, so equal-length contents must collide in both. The fingerprint stays a 5-tuple with one int digest.

Cost per axis object on a structured (label, x, y, z) axis: 0.36 → 1.0 µs at 256 channels, 1.3 → 3.8 µs at 1024 (blake2b would be ~10 / 39 µs). test_a_crc32_collision_is_still_told_apart constructs a genuine crc32 collision (CRC is linear, so one can be solved for) and checks the fingerprints still differ.