Commit by commit

This PR redesigns re_types's traits in an effort to allow users to easily implement their own handwritten Archetypes/Components/Datatypes, or even extend builtin ones.
It also introduces the of notion of "component lists" as first-class citizens, which is the basis of our archetype extension story.

The new traits are designed in a way to make most of their methods optional, with sane default implementations that either return errors or automatically "do the right thing" by relying on other methods.
In most cases, this makes it possible to implement "just what you need", and everything should work fine.

The new LoggableList, ComponentList & DatatypeList traits allow for erased collections of components, and do not require any effort on part of the user as we provide blanket implementations for all common cases.

The legacy iterator-based compatibility layer in the deserialization path is gone.
Similarly, all the awful datatype extension hacks are gone. Extensions live in the Field and the Field alone, until we get rid of arrow2-convert and DataCell::component_name in the future.

Quoting the crate-level doc:

The [Archetype] trait is the core of this crate and is a good starting point to get familiar with the code.
An archetype is a logical collection of [Component]s that play well with each other.

Rerun (and the underlying Arrow data framework) is designed to work with large arrays of [Component]s, as opposed to single instances.
When multiple instances of a [Component] are put together in an array, they yield a [ComponentList]: the atomic unit of (de)serialization.

Internally, [Component]s are implemented using many different [Datatype]s.

All builtin archetypes, components and datatypes can be found in their respective top-level modules.

Fixes #3178
Part of #3103

Implementing a custom component is now fairly straightforward:

/// A custom [`rerun::Component`] that is backed by a builtin [`Float32`] scalar [`rerun::Datatype`].
#[derive(Debug, Clone, Copy)]
struct Confidence(Float32);

impl Loggable for Confidence {
    type Name = ComponentName;

    fn name() -> Self::Name {
        "user.Confidence".into()
    }

    fn arrow_datatype() -> arrow2::datatypes::DataType {
        Float32::arrow_datatype()
    }

    fn try_to_arrow_opt<'a>(
        data: impl IntoIterator<Item = Option<impl Into<std::borrow::Cow<'a, Self>>>>,
    ) -> re_types::SerializationResult<Box<dyn arrow2::array::Array>>
    where
        Self: 'a,
    {
        Float32::try_to_arrow_opt(data.into_iter().map(|opt| opt.map(Into::into).map(|c| c.0)))
    }
}

And so is implementing a custom archetype:

/// A custom [`Archetype`] that extends Rerun's builtin [`Points3D`] archetype with extra
/// [`rerun::Component`]s.
struct CustomPoints3D {
    points3d: Points3D,
    confidences: Option<Vec<Confidence>>,
}

impl Archetype for CustomPoints3D {
    fn name() -> ArchetypeName {
        "user.CustomPoints3D".into()
    }

    fn required_components() -> std::borrow::Cow<'static, [rerun::ComponentName]> {
        Points3D::required_components()
    }

    fn recommended_components() -> std::borrow::Cow<'static, [rerun::ComponentName]> {
        Points3D::recommended_components()
            .iter()
            .copied()
            .chain([Confidence::name()])
            .collect::<Vec<_>>()
            .into()
    }

    fn optional_components() -> std::borrow::Cow<'static, [rerun::ComponentName]> {
        Points3D::optional_components()
    }

    fn num_instances(&self) -> usize {
        self.points3d.num_instances()
    }

    fn as_component_lists(&self) -> Vec<&dyn ComponentList> {
        // TODO(#3159): need an easy way to get a CustomPoints3DIndicator component in here!
        self.points3d
            .as_component_lists()
            .into_iter()
            .chain(
                std::iter::once(self.confidences.as_ref().map(|v| v as &dyn ComponentList))
                    .flatten(),
            )
            .collect()
    }
}

As a nice side-effect of these simplified traits, the custom_space_view example is now much simpler:

What

Checklist

• I have read and agree to Contributor Guide and the Code of Conduct
• I've included a screenshot or gif (if applicable)
• I have tested demo.rerun.io (if applicable)

• PR Build Summary
• Docs preview
• Examples preview
• Recent benchmark results
• Wasm size tracking