Call world.flush() after mark_spawn_despawn() (#21397)

# Objective

During despawn, commands are flushed before writing the `despawned_by`
location. This means that commands run by observers will not see the
updated value. It also means an entity spawned by one of those commands
that re-uses the entity index may have its `spawned_by` overwritten by
the `despawned_by` meant for the original entity.

## Solution

Move the call to `world.flush()` after the call to
`mark_spawn_despawn()`.

## Testing

Added a unit test demonstrating the issue.

Author: chescock

crates/bevy_ecs/src/world/entity_ref.rs

@@ -2703,14 +2703,15 @@ impl<'w> EntityWorldMut<'w> {
             world.archetypes[moved_location.archetype_id]
                 .set_entity_table_row(moved_location.archetype_row, table_row);
         }
-        world.flush();
 
         // SAFETY: `self.entity` is a valid entity index
         unsafe {
             world
                 .entities
                 .mark_spawn_despawn(self.entity.index(), caller, change_tick);
         }
+
+        world.flush();
     }
 
     /// Ensures any commands triggered by the actions of Self are applied, equivalent to [`World::flush`]
@@ -6765,4 +6766,34 @@ mod tests {
         let spawn_after = world.entity(id3).spawned_by();
         assert_eq!(spawn, spawn_after);
     }
+
+    #[test]
+    fn spawned_by_set_before_flush() {
+        #[derive(Component)]
+        #[component(on_despawn = on_despawn)]
+        struct C;
+
+        fn on_despawn(mut world: DeferredWorld, context: HookContext) {
+            let spawned = world.entity(context.entity).spawned_by();
+            world.commands().queue(move |world: &mut World| {
+                // The entity has finished despawning...
+                assert!(world.get_entity(context.entity).is_err());
+                let despawned = world
+                    .entities()
+                    .entity_get_spawned_or_despawned_by(context.entity);
+                // These assertions are only possible if the `track_location` feature is enabled
+                if let (Some(spawned), Some(despawned)) =
+                    (spawned.into_option(), despawned.into_option())
+                {
+                    // ... so ensure that `despawned_by` has been written
+                    assert!(despawned.is_some());
+                    assert_ne!(Some(spawned), despawned);
+                }
+            });
+        }
+
+        let mut world = World::new();
+        let original = world.spawn(C).id();
+        world.despawn(original);
+    }
 }