Fix: OOB read in sz_order_skylake tail for length-mismatched strings

The tail used masked loads with different masks for `a` and `b`, then an
unmasked `_mm512_cmpneq_epi8_mask`. When one string was shorter, its
masked-off lanes were zero, so the longer string's bytes in those lanes
compared as "not equal" against zero, producing spurious mismatch bits
beyond `min(a_length, b_length)`. The follow-up `a[first_diff]` /
`b[first_diff]` then read past the shorter buffer and could return a
wrong ordering whenever the random byte at the OOB index outranked the
real one — manifesting in `sz_sequence_argsort_with_insertion` as the
empty string being placed after non-empty strings starting with `\0`,
which made `test_sorting_algorithms` abort on the `"ab\0"` alphabet.

Restrict the compare to `a_mask & b_mask` (the bytes valid in both)
using the masked `_mm512_mask_cmpneq_epi8_mask`, mirroring how the head
section and `sz_equal_skylake` already handle masked tails.

Author: ashvardanian

include/stringzilla/compare.h

@@ -374,10 +374,12 @@ SZ_PUBLIC sz_ordering_t sz_order_skylake(sz_cptr_t a, sz_size_t a_length, sz_cpt
         b_mask = sz_u64_clamp_mask_until_(b_length);
         a_vec.zmm = _mm512_maskz_loadu_epi8(a_mask, a);
         b_vec.zmm = _mm512_maskz_loadu_epi8(b_mask, b);
-        // The AVX-512 `_mm512_mask_cmpneq_epi8_mask` intrinsics are generally handy in such environments.
-        // They, however, have latency 3 on most modern CPUs. Using AVX2: `_mm256_cmpeq_epi8` would have
-        // been cheaper, if we didn't have to apply `_mm256_movemask_epi8` afterwards.
-        mask_not_equal = _mm512_cmpneq_epi8_mask(a_vec.zmm, b_vec.zmm);
+        // Restrict the comparison to bytes valid in both strings. The masked loads zero out lanes
+        // past each string's end, so an unmasked compare would see spurious mismatches against
+        // those zeros in the longer string's tail and read out of bounds for the shorter one
+        // (e.g. `sz_order("\0baa", 4, "", 0)` would dereference `b[1]`).
+        __mmask64 const common_mask = a_mask & b_mask;
+        mask_not_equal = _mm512_mask_cmpneq_epi8_mask(common_mask, a_vec.zmm, b_vec.zmm);
         if (mask_not_equal != 0) {
             // Reload from original memory (L1 cached) to avoid ZMM-to-stack spill.
             sz_u64_t first_diff = _tzcnt_u64(mask_not_equal);