chore: forbid the locking Id constructors with a clippy lint (#8617)

## Summary

Follow-up to #8614. A `clippy` disallowed-methods lint now forbids
`Id::new` and `Id::new_static` workspace-wide, since both intern into a
globally locked table (`ThreadedRodeo`) on every call. Static
identifiers must use a `CachedId` static instead; the sites that intern
a genuinely dynamic string (proto/flatbuffer deserialization, arrow
extension lookups, Python read contexts, tests) keep `Id::new` behind an
`#[expect(clippy::disallowed_methods, reason = "...")]`. `CachedId`
itself now interns through `Id::new_static`, so it is the single
sanctioned path for static ids.

This is the enforcement half of #8380; #8614 did the migration. It is
stacked on #8614, so it stays a draft until that merges; the shared
migration commit drops out once this is rebased onto a merged #8614.

Refs: #8380

## Testing

`cargo clippy --all-targets` is clean across the edited crates
(`vortex-array`, `vortex-layout`, `vortex-file`, `vortex-ipc`,
`vortex-zstd`, `vortex-python`, `vortex-duckdb`, `vortex-session`), with
`disallowed_methods` and `unfulfilled_lint_expectations` both at zero;
`cargo +nightly fmt --all --check` clean. `vortex-cuda` could not be
built locally (no CUDA toolchain).

---

I'm Korean, so sorry if any wording reads a little awkward.

Signed-off-by: Han Damin <miniex@daminstudio.net>

Author: miniex

clippy.toml

@@ -15,4 +15,6 @@ disallowed-methods = [
     { path = "itertools::Itertools::counts", reason = "It uses the default hasher which is slow for primitives. Just inline the loop for better performance.", allow-invalid = true },
     { path = "std::result::Result::and", reason = "This method is a footgun, especially when working with `Result<Validity>`." },
     { path = "std::thread::available_parallelism", reason = "This function might do an unbounded amount of work, use `vortex_utils::parallelism::get_available_parallelism instead" },
+    { path = "vortex_session::registry::Id::new", reason = "Interning a static id on every call grabs the interner lock (#8380). Use a `CachedId` static for static ids; for a dynamic string, annotate the call with `#[expect(clippy::disallowed_methods)]`.", allow-invalid = true },
+    { path = "vortex_session::registry::Id::new_static", reason = "Interning a static id on every call grabs the interner lock; use a `CachedId` static instead (#8380).", allow-invalid = true },
 ]

encodings/zstd/src/zstd_buffers.rs

@@ -348,6 +348,7 @@ fn compute_output_layout(
     (offsets, total_size)
 }
 
+#[expect(clippy::disallowed_methods, reason = "interning a dynamic id")]
 fn array_id_from_string(s: &str) -> ArrayId {
     ArrayId::new(s)
 }

vortex-array/src/aggregate_fn/proto.rs

@@ -35,6 +35,7 @@ impl AggregateFnRef {
     ///
     /// Note: the serialization format is not stable and may change between versions.
     pub fn from_proto(proto: &pb::AggregateFn, session: &VortexSession) -> VortexResult<Self> {
+        #[expect(clippy::disallowed_methods, reason = "interning a dynamic id")]
         let agg_fn_id: AggregateFnId = AggregateFnId::new(proto.id.as_str());
         let agg_fn = if let Some(plugin) = session.aggregate_fns().find_plugin(&agg_fn_id) {
             plugin.deserialize(proto.metadata(), session)?
@@ -88,6 +89,7 @@ mod tests {
         type Options = EmptyOptions;
         type Partial = ();
 
+        #[expect(clippy::disallowed_methods, reason = "test-only id")]
         fn id(&self) -> AggregateFnId {
             AggregateFnId::new("vortex.test.proto")
         }

vortex-array/src/arrays/extension/compute/rules.rs

@@ -120,6 +120,7 @@ mod tests {
         type Metadata = EmptyMetadata;
         type NativeValue<'a> = &'a str;
 
+        #[expect(clippy::disallowed_methods, reason = "test-only id")]
         fn id(&self) -> ExtId {
             ExtId::new("test_ext")
         }
@@ -244,6 +245,7 @@ mod tests {
             type Metadata = EmptyMetadata;
             type NativeValue<'a> = &'a str;
 
+            #[expect(clippy::disallowed_methods, reason = "test-only id")]
             fn id(&self) -> ExtId {
                 ExtId::new("test_ext_2")
             }

vortex-array/src/arrow/session.rs

@@ -314,6 +314,7 @@ impl ArrowSession {
     /// family, [`DataType::FixedSizeList`], [`DataType::Struct`]) so extension metadata
     /// on nested element/struct fields is preserved. Leaf types use the canonical
     /// Arrow → Vortex mapping via [`DType::try_from_arrow`].
+    #[expect(clippy::disallowed_methods, reason = "interning a dynamic id")]
     pub fn from_arrow_field(&self, field: &Field) -> VortexResult<DType> {
         if let Some(name) = field.metadata().get(EXTENSION_TYPE_NAME_KEY) {
             for plugin in self.importers(&Id::new(name)).iter() {
@@ -406,6 +407,7 @@ impl ArrowSession {
     ///
     /// With `target = None` the fallback path picks the array's preferred Arrow physical type
     /// and executes directly into that, ignoring extension types.
+    #[expect(clippy::disallowed_methods, reason = "interning a dynamic id")]
     pub fn execute_arrow(
         &self,
         array: ArrayRef,
@@ -474,6 +476,7 @@ impl ArrowSession {
     /// through to the canonical Arrow → Vortex array conversion.
     pub fn from_arrow_array(&self, array: ArrowArrayRef, field: &Field) -> VortexResult<ArrayRef> {
         if let Some(extension_name) = field.metadata().get(EXTENSION_TYPE_NAME_KEY) {
+            #[expect(clippy::disallowed_methods, reason = "interning a dynamic id")]
             let importers = self.importers(&Id::new(extension_name));
             if !importers.is_empty() {
                 let dtype = self.from_arrow_field(field)?;

vortex-array/src/dtype/serde/flatbuffers.rs

@@ -207,6 +207,7 @@ impl TryFrom<ViewedDType> for DType {
                 let fb_ext = fb
                     .type__as_extension()
                     .ok_or_else(|| vortex_err!("failed to parse extension from flatbuffer"))?;
+                #[expect(clippy::disallowed_methods, reason = "interning a dynamic id")]
                 let id =
                     ExtId::new(fb_ext.id().ok_or_else(|| {
                         vortex_err!("failed to parse extension id from flatbuffer")

vortex-array/src/dtype/serde/proto.rs

@@ -89,6 +89,7 @@ impl DType {
             DtypeType::Union(u) => Ok(Self::Union(u.nullable.into())),
             DtypeType::Variant(v) => Ok(Self::Variant(v.nullable.into())),
             DtypeType::Extension(e) => {
+                #[expect(clippy::disallowed_methods, reason = "interning a dynamic id")]
                 let id = ExtId::new(e.id.as_str());
                 let storage_dtype = DType::from_proto(
                     e.storage_dtype

vortex-array/src/dtype/serde/serde.rs

@@ -577,6 +577,7 @@ impl<'de> DeserializeSeed<'de> for DTypeSerde<'_, ExtDTypeRef> {
                 }
 
                 let id = id.ok_or_else(|| de::Error::missing_field("id"))?;
+                #[expect(clippy::disallowed_methods, reason = "interning a dynamic id")]
                 let id = ExtId::new(&id);
                 let storage_dtype =
                     storage_dtype.ok_or_else(|| de::Error::missing_field("storage_dtype"))?;

vortex-array/src/expr/proto.rs

@@ -39,6 +39,7 @@ impl ExprSerializeProtoExt for Expression {
 
 impl Expression {
     pub fn from_proto(expr: &pb::Expr, session: &VortexSession) -> VortexResult<Expression> {
+        #[expect(clippy::disallowed_methods, reason = "interning a dynamic id")]
         let expr_id = ScalarFnId::new(expr.id.as_str());
         let children = expr
             .children

vortex-array/src/extension/tests/divisible_int.rs

@@ -34,6 +34,7 @@ impl ExtVTable for DivisibleInt {
     type Metadata = Divisor;
     type NativeValue<'a> = u64;
 
+    #[expect(clippy::disallowed_methods, reason = "test-only id")]
     fn id(&self) -> ExtId {
         ExtId::new("test.divisible_int")
     }