(improvement) Optimize Cython deserialization primitives and add VectorType Cython deserializer

[mykaul]

Summary

• Optimize foundational Cython byte-unpacking with ntohs()/ntohl() intrinsics and int.from_bytes() — ~4-5% end-to-end row throughput improvement
• Add float-specific ntohl() byte-swap (4-8x per-element float speedup)
• Add dedicated DesVectorType Cython deserializer with type-specialized C-level deserialization
• Add buffer bounds validation and Windows portability for the Cython layer

Commits (6, ordered by dependency)

1. Optimize Cython byte unpacking with ntohs/ntohl and int.from_bytes

• Replace generic byte-swap loop in unpack_num() with ntohs()/ntohl() intrinsics for 16/32-bit types (compiles to single bswap on x86)
• Replace varint_unpack() hex-string-based conversion with int.from_bytes(term, 'big', signed=True) — 4-18x speedup
• Simplify read_int() to direct pointer cast + ntohl()
• Remove slice_buffer(), replace all call sites with from_ptr_and_size()

2. Optimize float deserialization with ntohl() intrinsic

• Add float-specific branch: reinterpret float bits as uint32_t, apply ntohl(), reinterpret back to float
• Eliminates 4-iteration byte-swap loop for every float value
• 4-8x speedup for float unmarshaling on little-endian systems

3. Refactor to use from_ptr_and_size() helper consistently

• Replace manual buf.ptr = ...; buf.size = ... patterns with from_ptr_and_size() calls
• Use memcpy + ntohl instead of direct pointer dereference for alignment safety

4. Optimize VectorType deserialization with Cython deserializer

• New DesVectorType class with specialized deserialization methods:
  • _deserialize_float(): C-level memcpy + ntohl + pointer-cast loop (no Python dispatch per element)
  • _deserialize_double() / _deserialize_int64(): 8-byte manual byte-swap
  • _deserialize_int32(): memcpy + ntohl + cast
  • Numpy fast-path for vectors >= 32 elements
  • Generic fallback for other fixed-size types
• Automatically registered via find_deserializer() for the Cython row parser
• 4.4-4.7x faster than pure Python for small vectors (3-4 elements)

5. Add Windows support for ntohl/ntohs with platform-specific headers

• Replace arpa/inet.h with platform-conditional #ifdef _WIN32 block including winsock2.h on Windows
• Use memcpy + ntohl in read_int() for alignment safety

6. Add buffer bounds validation to Cython deserializers

• Full CQL protocol compliance in subelem(): NULL, "not set", and negative length handling
• Bounds checking in _unpack_len(), DesTupleType, DesCompositeType, DesVectorType._deserialize_generic()
• Remove int16 fast path (ShortType goes through generic path)

Performance Impact on Vector<float, 768/1536>

For small vectors (< 32 elements): The Cython C-loop path avoids all Python method dispatch, delivering 4-5x speedup over pure Python.

For large vectors (768/1536): Both Cython and pure Python paths delegate to numpy.frombuffer().tolist(), so the Cython overhead reduction is marginal per-vector — but eliminates per-row Python dispatch overhead when processing many rows.