refactor: make the fixed-point price encoding internal

[userFRM]

Summary

A price is encoded as a (value, price_type) mantissa-and-exponent pair where the real price is value * 10^(price_type - 10). That variable-precision fixed-point encoding is a wire-transport detail. A client of this crate receives decoded prices (f64 dollars on the tick rows, via to_f64), so it must never see, set, or reason about the raw (value, price_type) pair. This PR makes the encoding internal: it removes Price, PriceType, PriceError, and MAX_PRICE_TYPE from the public API, and it hardens the exponent so only the validated internal decode path can construct a Price.

Make the encoding internal

Price and its supporting types were re-exported on the curated public surface (thetadatadx::Price, thetadatadx::PriceType, thetadatadx::PriceError, thetadatadx::MAX_PRICE_TYPE) and on the internal tdbe / tdbe::types facades. None of that is needed by a client: every public tick row already carries the decoded f64 price, and no public function or binding accepts or returns a Price. The pair never crosses a binding boundary.

These types are now gated behind the __internal feature (doc-hidden, with the same "NOT a stable public surface" contract as the other wire-internal re-exports), so they stay reachable for workspace tools, bindings, and the data-format benches but are absent from the default public API and from rendered rustdoc. The decode layer reaches them through the full tdbe::types::price leaf path, never a short facade alias, so the encoding cannot drift back onto the public surface through a convenience re-export. The price_type tick-schema column is a positional wire-layout field the parser reads and discards; it was already not a client-facing struct field in any binding, so no tick row exposes the raw exponent.

Parse, don't validate: the exponent is unrepresentable out of range

The decimal exponent is a validated PriceType newtype over 0..=MAX_PRICE_TYPE. Its only constructors check the range:

• PriceType::new(i32) -> Result<_, PriceError> / TryFrom<i32> rejects out of range with a typed error.
• PriceType::saturating(i32) is infallible, snapping into range at the nearest boundary; it backs the lossy Price::new.

Because an out-of-range exponent cannot be constructed, exp = price_type - 10 is confined to -10..=9 and exp.unsigned_abs() indexes the precomputed POW10_I64 / POW10_F64 tables in bounds by construction. The per-read clamps in to_f64, Display, and compare are gone; the table access is provably in range with no runtime check and no path that can observe or fabricate a result from an out-of-range exponent. The earlier panic class is eliminated because only the validated decode boundary constructs a Price: the wire decode path (FPSS / MDDS) constructs through the fallible Price::with_value_and_type, which threads PriceType::new and rejects out-of-range cells exactly as before; Price::new keeps its saturating contract via PriceType::saturating so existing infallible callers stay panic-free.

Why this is ABI-safe

Price is a pure-Rust internal type, with evidence:

• No #[repr(C)], no layout assertion, no bytemuck / zerocopy traits on Price.
• No C / C++ / Python / TypeScript binding reads Price's raw fields. The C ABI exposes PriceTick, which carries a decoded double price, not Price. The layout-assert suite covers PriceTick, not Price.
• Bindings obtain the price exclusively as the decoded f64 via to_f64; the (value, price_type) pair never crosses a binding boundary.

So removing the public re-export and changing the field type from i32 to PriceType cannot break any ABI. Verified: thetadatadx-ffi, thetadatadx-py, and thetadatadx-napi all build against the default-feature crate; the tick layout-assert suite (incl. price_tick_layout) passes unchanged.

Tests

• price_type_rejects_out_of_range accepts 0..=19 and rejects -1, 20, 99, i32::MIN, i32::MAX; out-of-range is unrepresentable.
• price_type_saturating_clamps_to_boundaries snaps at both ends and leaves in-range values untouched.
• every_price_type_indexes_tables_in_bounds and every_valid_price_type_renders_and_converts_finitely pin that every representable exponent indexes the tables in bounds and converts finitely.
• in_range_conversions_are_unchanged pins value=12345/type=8 -> 123.45, 5/12 -> 500.0, 100/10 -> 100.0 for both to_f64 and Display.
• with_value_and_type_enforces_range, accessors_match_fields, is_unset_vs_is_zero_value, new_saturates_out_of_range_price_type retained.

Verification: cargo fmt --all -- --check; cargo test -p thetadatadx --lib (815 passed); FFI + Python + TypeScript binding crates build; binding-parity check clean; git grep confirms the default public surface no longer names Price / PriceType / PriceError / MAX_PRICE_TYPE.