Store short strings inline instead of interning them (#24)

[Diggsey]

Closes #24.

Implements the inline short-string optimization sketched in the issue thread: strings up to size_of::<usize>() - 1 bytes — 7 on 64-bit, 3 on 32-bit — are encoded directly inside the pointer-sized IValue, skipping both the allocation and the global-cache lookup. This covers the common case of short JSON keys/values ("id", "no", "yes", "type", "x", …). Longer strings are interned exactly as before.

Encoding

An inline string reuses the StringOrNull tag and adds a discriminator in the low control byte:

bits 0–1	bit 2	bits 3–5	remaining bytes
tag 01	1 = inline	length	up to INLINE_CAPACITY UTF-8 bytes

• Bit 2 distinguishes inline from a heap string pointer. For that to be reliable, the heap Header is now 8-aligned so heap pointers always have bit 2 clear. On 64-bit that was already true (the AtomicUsize refcount forces 8-alignment); the explicit #[repr(align(8))] is what makes the optimization work on 32-bit (costs ~4 bytes of header padding, only on interned strings).
• null (value 1) has bit 2 clear, so it stays distinct from inline strings; the niche is preserved (inline values are non-zero), so Option<IValue> stays pointer-sized.

Why it's sound

Everything rests on one invariant: representation is a pure function of content — len ≤ INLINE_CAPACITY ⇒ inline, otherwise interned. So two equal strings always share a representation, and IString's pointer-based ==/hash stay correct (an inline value's bits are its content).

Endianness

The control byte is kept in the value's low byte on both endiannesses (so tag/flag/length live in well-defined bits via ptr_usize()); only the in-memory character offset differs, handled with cfg(target_endian).

Behaviour change

IString::as_str().as_ptr() is no longer stable across equal short strings — they're no longer deduplicated to a shared allocation (they use no heap at all). Value equality via == is unaffected. Two existing tests that asserted pointer identity for short strings were updated to use long strings; new tests cover the inline path.

Validation

Full platform/endianness matrix:

Target	How
x86-64 LE (native)	cargo test (36 pass) + cargo miri test (no UB)
i686 LE (32-bit)	cargo test --target i686-pc-windows-msvc (36 pass)
s390x BE (64-bit)	cargo miri test --target s390x-… (emulated, pass)
powerpc BE (32-bit)	cargo miri test --target powerpc-… (emulated, pass)

Plus clippy --all-targets --all-features and fmt --check clean. New tests cover: inline round-trip for lengths 0..=CAP incl. multibyte UTF-8, the CAP/CAP+1 inline↔heap boundary, empty-string-is-inline-not-null, and mixed inline/heap keys in an IObject.

Scope

Addresses request (1) fully and request (2) for the common case (short unique strings now cost nothing). Not interning long unique strings is a deliberate non-goal: without canonicalization, IString's O(1) pointer equality/hash — the crate's core value — would break.