feat(simd): Tier 3 — U16x32 lane type + movemask_epi8

Completes the seismon rasterizer wishlist (all 3 tiers shipped).

U16x32 (32 × u16 in one __m512i):
  - splat, zero, from_slice, from_array, to_array, copy_to_slice
  - Add, Sub, AddAssign operators
  - from_u8x64_lo / from_u8x64_hi — widen u8→u16 (zero-extend)
  - pack_saturate_u8 — narrow u16→u8 (unsigned saturation)
  - shr / shl — immediate shift per 16-bit lane
  - mullo — wrapping multiply, keep low 16 bits
  - reduce_sum → u32
  - AVX-512 native: _mm512_set1_epi16, _mm512_cvtepu8_epi16,
    _mm512_packus_epi16, _mm512_srli/slli_epi16, _mm512_mullo_epi16,
    _mm512_add/sub_epi16
  - AVX2 + scalar: matching loop fallbacks

U8x64::movemask() → u64:
  - Extract MSB of each byte as 64-bit mask
  - AVX-512: _mm512_movepi8_mask (single instruction)
  - Scalar: (byte & 0x80) != 0 loop
  - Empty-tile skip: if movemask(row) == 0 → skip entire 64-pixel row

Tests: 12 new tier3_tests (movemask ×3, U16x32 splat/add/widen_lo/
widen_hi/pack_saturate ×2/mullo/shift_roundtrip/reduce_sum). All pass.

All three SIMD backends (simd_avx512.rs, simd_avx2.rs, simd.rs) updated.
Consumer writes crate::simd::U16x32 / crate::simd::U8x64::movemask().

https://claude.ai/code/session_01SbYsmmbPf9YQuYbHZN52Zh

Author: claude

src/simd.rs

@@ -118,7 +118,7 @@ pub use crate::simd_avx512::{
     // 256-bit (AVX2 baseline, __m256/__m256d)
     F32x8, F64x4, f32x8, f64x4,
     // 512-bit (native AVX-512, __m512/__m512d/__m512i)
-    F32x16, F64x8, U8x64, I32x16, I64x8, U32x16, U64x8,
+    F32x16, F64x8, U8x64, I32x16, I64x8, U16x32, U32x16, U64x8,
     F32Mask16, F64Mask8,
     f32x16, f64x8, u8x64, i32x16, i64x8, u32x16, u64x8,
 };
@@ -152,7 +152,7 @@ pub use crate::simd_avx512::{F32x8, F64x4, f32x8, f64x4};
 
 #[cfg(all(target_arch = "x86_64", not(target_feature = "avx512f")))]
 pub use crate::simd_avx2::{
-    F32x16, F64x8, U8x64, I32x16, I64x8, U32x16, U64x8,
+    F32x16, F64x8, U8x64, I32x16, I64x8, U16x32, U32x16, U64x8,
     F32Mask16, F64Mask8,
     f32x16, f64x8, u8x64, i32x16, i64x8, u32x16, u64x8,
 };
@@ -551,9 +551,41 @@ mod scalar {
     impl_int_type!(U8x64, u8, 64, 0u8);
     impl_int_type!(I32x16, i32, 16, 0i32);
     impl_int_type!(I64x8, i64, 8, 0i64);
+    impl_int_type!(U16x32, u16, 32, 0u16);
     impl_int_type!(U32x16, u32, 16, 0u32);
     impl_int_type!(U64x8, u64, 8, 0u64);
 
+    // Extra methods for U16x32 (widen/narrow, shift, multiply)
+    impl U16x32 {
+        #[inline(always)]
+        pub fn from_u8x64_lo(v: U8x64) -> Self {
+            let mut out = [0u16; 32]; for i in 0..32 { out[i] = v.0[i] as u16; } Self(out)
+        }
+        #[inline(always)]
+        pub fn from_u8x64_hi(v: U8x64) -> Self {
+            let mut out = [0u16; 32]; for i in 0..32 { out[i] = v.0[32 + i] as u16; } Self(out)
+        }
+        #[inline(always)]
+        pub fn pack_saturate_u8(self, other: Self) -> U8x64 {
+            let mut out = [0u8; 64];
+            for i in 0..32 { out[i] = self.0[i].min(255) as u8; }
+            for i in 0..32 { out[32 + i] = other.0[i].min(255) as u8; }
+            U8x64(out)
+        }
+        #[inline(always)]
+        pub fn shr(self, imm: u32) -> Self {
+            let mut out = [0u16; 32]; for i in 0..32 { out[i] = if imm < 16 { self.0[i] >> imm } else { 0 }; } Self(out)
+        }
+        #[inline(always)]
+        pub fn shl(self, imm: u32) -> Self {
+            let mut out = [0u16; 32]; for i in 0..32 { out[i] = if imm < 16 { self.0[i] << imm } else { 0 }; } Self(out)
+        }
+        #[inline(always)]
+        pub fn mullo(self, other: Self) -> Self {
+            let mut out = [0u16; 32]; for i in 0..32 { out[i] = self.0[i].wrapping_mul(other.0[i]); } Self(out)
+        }
+    }
+
     // Extra methods for I32x16 that float types have via the macro
     impl I32x16 {
         #[inline(always)]
@@ -842,6 +874,10 @@ mod scalar {
             let mut out = [0u8; 64]; for i in 0..64 { out[i] = self.0[(idx.0[i] & 63) as usize]; } Self(out)
         }
         #[inline(always)]
+        pub fn movemask(self) -> u64 {
+            let mut m: u64 = 0; for i in 0..64 { if self.0[i] & 0x80 != 0 { m |= 1 << i; } } m
+        }
+        #[inline(always)]
         pub fn unpack_lo_epi8(self, other: Self) -> Self {
             let mut out = [0u8; 64];
             for lane in 0..4 { let b = lane * 16; for i in 0..8 { out[b+i*2] = self.0[b+i]; out[b+i*2+1] = other.0[b+i]; } }
@@ -905,7 +941,7 @@ mod scalar {
 
 #[cfg(not(target_arch = "x86_64"))]
 pub use scalar::{
-    F32x16, F64x8, U8x64, I32x16, I64x8, U32x16, U64x8,
+    F32x16, F64x8, U8x64, I32x16, I64x8, U16x32, U32x16, U64x8,
     F32x8, F64x4,
     F32Mask16, F64Mask8,
     f32x16, f64x8, u8x64, i32x16, i64x8, u32x16, u64x8,

src/simd_avx2.rs

@@ -842,6 +842,10 @@ impl U8x64 {
     pub fn permute_bytes(self, idx: Self) -> Self {
         let mut out = [0u8; 64]; for i in 0..64 { out[i] = self.0[(idx.0[i] & 63) as usize]; } Self(out)
     }
+    #[inline(always)]
+    pub fn movemask(self) -> u64 {
+        let mut m: u64 = 0; for i in 0..64 { if self.0[i] & 0x80 != 0 { m |= 1 << i; } } m
+    }
 
     /// Interleave low bytes within each 128-bit lane.
     #[inline(always)]
@@ -909,9 +913,41 @@ impl U8x64 {
 
 avx2_int_type!(I32x16, i32, 16, 0i32);
 avx2_int_type!(I64x8, i64, 8, 0i64);
+avx2_int_type!(U16x32, u16, 32, 0u16);
 avx2_int_type!(U32x16, u32, 16, 0u32);
 avx2_int_type!(U64x8, u64, 8, 0u64);
 
+// Extra methods for U16x32 (widen/narrow, shift, multiply) — AVX2 scalar fallback.
+impl U16x32 {
+    #[inline(always)]
+    pub fn from_u8x64_lo(v: U8x64) -> Self {
+        let mut out = [0u16; 32]; for i in 0..32 { out[i] = v.0[i] as u16; } Self(out)
+    }
+    #[inline(always)]
+    pub fn from_u8x64_hi(v: U8x64) -> Self {
+        let mut out = [0u16; 32]; for i in 0..32 { out[i] = v.0[32 + i] as u16; } Self(out)
+    }
+    #[inline(always)]
+    pub fn pack_saturate_u8(self, other: Self) -> U8x64 {
+        let mut out = [0u8; 64];
+        for i in 0..32 { out[i] = self.0[i].min(255) as u8; }
+        for i in 0..32 { out[32 + i] = other.0[i].min(255) as u8; }
+        U8x64(out)
+    }
+    #[inline(always)]
+    pub fn shr(self, imm: u32) -> Self {
+        let mut out = [0u16; 32]; for i in 0..32 { out[i] = if imm < 16 { self.0[i] >> imm } else { 0 }; } Self(out)
+    }
+    #[inline(always)]
+    pub fn shl(self, imm: u32) -> Self {
+        let mut out = [0u16; 32]; for i in 0..32 { out[i] = if imm < 16 { self.0[i] << imm } else { 0 }; } Self(out)
+    }
+    #[inline(always)]
+    pub fn mullo(self, other: Self) -> Self {
+        let mut out = [0u16; 32]; for i in 0..32 { out[i] = self.0[i].wrapping_mul(other.0[i]); } Self(out)
+    }
+}
+
 impl I32x16 {
     #[inline(always)] pub fn reduce_min(self) -> i32 { *self.0.iter().min().unwrap() }
     #[inline(always)] pub fn reduce_max(self) -> i32 { *self.0.iter().max().unwrap() }