Make builder types take and return Self (bevyengine#10001)

# Objective

Closes bevyengine#9955.

Use the same interface for all "pure" builder types: taking and
returning `Self` (and not `&mut Self`).

## Solution

Changed `DynamicSceneBuilder`, `SceneFilter` and `TableBuilder` to take
and return `Self`.

## Changelog

### Changed

- `DynamicSceneBuilder` and `SceneBuilder` methods in `bevy_ecs` now
take and return `Self`.

## Migration guide

When using `bevy_ecs::DynamicSceneBuilder` and `bevy_ecs::SceneBuilder`,
instead of binding the builder to a variable, directly use it. Methods
on those types now consume `Self`, so you will need to re-bind the
builder if you don't `build` it immediately.

Before:
```rust
let mut scene_builder = DynamicSceneBuilder::from_world(&world);
let scene = scene_builder.extract_entity(a).extract_entity(b).build();
```

After:
 ```rust
let scene = DynamicSceneBuilder::from_world(&world)
    .extract_entity(a)
    .extract_entity(b)
    .build();
```

crates/bevy_ecs/src/storage/table.rs

@@ -526,13 +526,16 @@ impl TableBuilder {
         }
     }
 
-    pub fn add_column(&mut self, component_info: &ComponentInfo) {
+    #[must_use]
+    pub fn add_column(mut self, component_info: &ComponentInfo) -> Self {
         self.columns.insert(
             component_info.id(),
             Column::with_capacity(component_info, self.capacity),
         );
+        self
     }
 
+    #[must_use]
     pub fn build(self) -> Table {
         Table {
             columns: self.columns.into_immutable(),
@@ -865,7 +868,7 @@ impl Tables {
             .or_insert_with(|| {
                 let mut table = TableBuilder::with_capacity(0, component_ids.len());
                 for component_id in component_ids {
-                    table.add_column(components.get_info_unchecked(*component_id));
+                    table = table.add_column(components.get_info_unchecked(*component_id));
                 }
                 tables.push(table.build());
                 (component_ids.to_vec(), TableId::new(tables.len() - 1))
@@ -929,9 +932,9 @@ mod tests {
         let mut storages = Storages::default();
         let component_id = components.init_component::<W<TableRow>>(&mut storages);
         let columns = &[component_id];
-        let mut builder = TableBuilder::with_capacity(0, columns.len());
-        builder.add_column(components.get_info(component_id).unwrap());
-        let mut table = builder.build();
+        let mut table = TableBuilder::with_capacity(0, columns.len())
+            .add_column(components.get_info(component_id).unwrap())
+            .build();
         let entities = (0..200).map(Entity::from_raw).collect::<Vec<_>>();
         for entity in &entities {
             // SAFETY: we allocate and immediately set data afterwards

crates/bevy_scene/src/dynamic_scene.rs

@@ -51,12 +51,10 @@ impl DynamicScene {
 
     /// Create a new dynamic scene from a given world.
     pub fn from_world(world: &World) -> Self {
-        let mut builder = DynamicSceneBuilder::from_world(world);
-
-        builder.extract_entities(world.iter_entities().map(|entity| entity.id()));
-        builder.extract_resources();
-
-        builder.build()
+        DynamicSceneBuilder::from_world(world)
+            .extract_entities(world.iter_entities().map(|entity| entity.id()))
+            .extract_resources()
+            .build()
     }
 
     /// Write the resources, the dynamic entities, and their corresponding components to the given world.
@@ -220,10 +218,10 @@ mod tests {
 
         // We then write this relationship to a new scene, and then write that scene back to the
         // world to create another parent and child relationship
-        let mut scene_builder = DynamicSceneBuilder::from_world(&world);
-        scene_builder.extract_entity(original_parent_entity);
-        scene_builder.extract_entity(original_child_entity);
-        let scene = scene_builder.build();
+        let scene = DynamicSceneBuilder::from_world(&world)
+            .extract_entity(original_parent_entity)
+            .extract_entity(original_child_entity)
+            .build();
         let mut entity_map = HashMap::default();
         scene.write_to_world(&mut world, &mut entity_map).unwrap();