Basic Extension Type Registry Implementation (#20312)

## Which issue does this PR close?

This is a PR based on #18552
that contains a basic implementation of an extension type registry. The
driving use case is pretty-printing data frames with custom types.

- Closes #18223.

Ping @paleolimbot @adriangb if you're still interested.

### Most Important Changes to the Old PR

- We no longer use the Logical Type, as there is no real conses on how
DataFusion should allow "inline" references to extension types. As a
consequence, the formatting query plans use case in the old PR no longer
works. Extension types can only be used where DataFusion has a reference
to a registry (e.g., DataFrame pretty-printing). @paleolimbot I've
called it `DFExtensionType` instead of `BoundExtensionType` to avoid the
need of explaining "bind". If you think there is merit in the other
term, let me know. I think otherwise, this aligns with your proposal.
- Added a more complex example with a parameterized type to demonstrate
the entire ability of the API
- No extension types are registered by default, users must opt-in

## Rationale for this change

- Allow customized behavior based on extension type metadata.

## What changes are included in this PR?

- Add an `ExtensionTypeRegistry`
- Add `DFArrayFormatterFactory` which creates custom pretty-printers
when formatting data frames.
- Add an extension type registry to the `SessionState` /
`SessionContext`
- A Full Example of using the API
- An implementation for the UUID canonical extension type

## Are these changes tested?

- Yes, but only two end-to-end tests.
  - One for pretty-printing UUID values
  - One for pretty-printing in the example

Happy to add more tests if this PR has a chance of being merged

## Are there any user-facing changes?

Yes, the entire Extension Type API is new.

Author: tobixdev

Cargo.lock

@@ -126,6 +126,16 @@ cargo run --example dataframe -- dataframe
 | mem_pool_tracking  | [`execution_monitoring/memory_pool_tracking.rs`](examples/execution_monitoring/memory_pool_tracking.rs)             | Demonstrates memory tracking             |
 | tracing            | [`execution_monitoring/tracing.rs`](examples/execution_monitoring/tracing.rs)                                       | Demonstrates tracing integration         |
 
+## Extension Types Examples
+
+### Group: `extension_types`
+
+#### Category: Single Process
+
+| Subcommand  | File Path                                                                   | Description                          |
+| ----------- | --------------------------------------------------------------------------- | ------------------------------------ |
+| temperature | [`extension_types/temperature.rs`](examples/extension_types/temperature.rs) | Extension type for temperature data. |
+
 ## External Dependency Examples
 
 ### Group: `external_dependency`

datafusion-examples/README.md

@@ -0,0 +1,84 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+//! # Extension type usage examples
+//!
+//! These examples demonstrate the API for creating and using custom extension types.
+//!
+//! ## Usage
+//! ```bash
+//! cargo run --example extension_types -- [all|temperature]
+//! ```
+//!
+//! Each subcommand runs a corresponding example:
+//! - `all` — run all examples included in this module
+//!
+//! - `temperature`
+//!   (file: temperature.rs, desc: Extension type for temperature data.)
+
+mod temperature;
+
+use datafusion::error::{DataFusionError, Result};
+use strum::{IntoEnumIterator, VariantNames};
+use strum_macros::{Display, EnumIter, EnumString, VariantNames};
+
+#[derive(EnumIter, EnumString, Display, VariantNames)]
+#[strum(serialize_all = "snake_case")]
+enum ExampleKind {
+    All,
+    Temperature,
+}
+
+impl ExampleKind {
+    const EXAMPLE_NAME: &str = "extension_types";
+
+    fn runnable() -> impl Iterator<Item = ExampleKind> {
+        ExampleKind::iter().filter(|v| !matches!(v, ExampleKind::All))
+    }
+
+    async fn run(&self) -> Result<()> {
+        match self {
+            ExampleKind::All => {
+                for example in ExampleKind::runnable() {
+                    println!("Running example: {example}");
+                    Box::pin(example.run()).await?;
+                }
+            }
+            ExampleKind::Temperature => {
+                temperature::temperature_example().await?;
+            }
+        }
+        Ok(())
+    }
+}
+
+#[tokio::main]
+async fn main() -> Result<()> {
+    let usage = format!(
+        "Usage: cargo run --example {} -- [{}]",
+        ExampleKind::EXAMPLE_NAME,
+        ExampleKind::VARIANTS.join("|")
+    );
+
+    let example: ExampleKind = std::env::args()
+        .nth(1)
+        .unwrap_or_else(|| ExampleKind::All.to_string())
+        .parse()
+        .map_err(|_| DataFusionError::Execution(format!("Unknown example. {usage}")))?;
+
+    example.run().await
+}