Fix CI: intersect initial array ids with the registry, docs links, doctest sizes

- Implement the intended semantics of the writer's pre-populated array
  context: `initial_array_ids` is the intersection of the session's
  enabled-edition encodings with the registered encodings, since an
  enabled edition may include encodings the session cannot serialize
  (e.g. an optional crate that is not compiled in). This completes the
  `initial_array_ids_are_registered_and_enabled` test and removes the
  unused `registry` binding and `Itertools` import that failed the
  lint jobs.
- Qualify the intra-doc links in the editions module docs: links in
  the module's inner docs resolve at the facade's `pub mod` site, so
  unqualified links break rustdoc under -D warnings.
- Restore the updated file-size golden values in the Python
  write-options doctests: the footer's encoding list changed with the
  edition-derived array context, shrinking the written files by 40
  bytes.

Signed-off-by: Claude <noreply@anthropic.com>
Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01CK2nCuXnyd2g3mNHQC8Lz2

Author: claude

vortex-file/src/writer.rs

@@ -15,8 +15,8 @@ use futures::future::LocalBoxFuture;
 use futures::future::ready;
 use futures::pin_mut;
 use futures::select;
-use itertools::Itertools;
 use vortex_array::ArrayContext;
+use vortex_array::ArrayId;
 use vortex_array::ArrayRef;
 use vortex_array::dtype::DType;
 use vortex_array::dtype::FieldPath;
@@ -157,8 +157,9 @@ impl VortexWriteOptions {
     ) -> VortexResult<WriteSummary> {
         // Pre-populate the array context with the registered encodings selected by the enabled
         // editions. This keeps the serialized ordering deterministic without advertising every
-        // encoding the session happens to know how to read.
-        let ctx = ArrayContext::new(self.session.enabled_encoding_ids())
+        // encoding the session happens to read or every enabled encoding the session cannot
+        // serialize.
+        let ctx = ArrayContext::new(initial_array_ids(&self.session))
             // The registry supplies serialization implementations; the layout strategy applies
             // the enabled-edition write policy before arrays reach serialization.
             .with_registry(self.session.arrays().registry().clone());
@@ -529,19 +530,35 @@ impl WriteSummary {
     }
 }
 
+/// The encoding ids used to pre-populate the writer's array context: every encoding of the
+/// session's enabled editions that is also registered with the session, in sorted order.
+///
+/// An enabled edition may include encodings the session has no registration for (e.g. an
+/// optional encoding crate that is not compiled in); those cannot be serialized, so they are
+/// not advertised in the context.
+fn initial_array_ids(session: &VortexSession) -> Vec<ArrayId> {
+    let registry = session.arrays().registry().clone();
+    session
+        .enabled_encoding_ids()
+        .into_iter()
+        .filter(|id| registry.find(id).is_some())
+        .collect()
+}
+
 #[cfg(test)]
 mod tests {
     use vortex_array::VTable;
     use vortex_array::array_session;
     use vortex_array::arrays::Bool;
     use vortex_array::arrays::Primitive;
-    use vortex_array::session::ArraySessionExt;
     use vortex_edition::Edition;
     use vortex_edition::EditionDeclaration;
     use vortex_edition::EditionId;
     use vortex_edition::EditionSession;
     use vortex_edition::EditionSessionExt;
 
+    use super::initial_array_ids;
+
     #[test]
     fn initial_array_ids_are_registered_and_enabled() -> Result<(), vortex_edition::EditionError> {
         const EDITION: EditionId = EditionId::new("test", 2026, 7, 0);
@@ -557,8 +574,7 @@ mod tests {
         session.register_edition(&DECLARATION)?;
         session.enable_edition(EDITION)?;
 
-        let registry = session.arrays().registry().clone();
-        let ids = session.enabled_encoding_ids();
+        let ids = initial_array_ids(&session);
         assert_eq!(ids, [Primitive.id()]);
         assert!(!ids.contains(&Bool.id()));
         Ok(())

vortex-python/src/io.rs

@@ -258,7 +258,7 @@ impl PyVortexWriteOptions {
     /// >>> vx.io.VortexWriteOptions.default().write(sprl, "chonky.vortex")
     /// >>> import os
     /// >>> os.path.getsize('chonky.vortex')
-    /// 215940
+    /// 215900
     ///
     /// Wow, Vortex manages to use about two bytes per integer! So advanced. So tiny.
     ///
@@ -268,7 +268,7 @@ impl PyVortexWriteOptions {
     ///
     /// >>> vx.io.VortexWriteOptions.compact().write(sprl, "tiny.vortex")
     /// >>> os.path.getsize('tiny.vortex')
-    /// 55068
+    /// 55028
     ///
     /// Random numbers are not (usually) composed of random bytes!
     #[staticmethod]

vortex/src/editions/mod.rs

@@ -5,12 +5,13 @@
 //!
 //! [`vortex_edition`] provides the types, session variables, and test harness. The actual
 //! first-party declarations live here, one module per edition. The default session first
-//! registers them with [`register_default_editions`] and then selects its write policy with
-//! [`enable_default_editions`].
+//! registers them with [`crate::editions::register_default_editions`] and then selects its
+//! write policy with [`crate::editions::enable_default_editions`].
 //!
 //! The default file writer resolves the session's enabled editions at write time. The
-//! facade enables the newest frozen `core` edition, [`CORE_2026_07_0`], and additionally
-//! enables the latest unstable edition when the `unstable_encodings` feature is selected.
+//! facade enables the newest frozen `core` edition, [`crate::editions::CORE_2026_07_0`],
+//! and additionally enables the latest unstable edition when the `unstable_encodings`
+//! feature is selected.
 
 pub mod core;
 #[cfg(test)]