Revert "Entity path methods and bsn entity path resolving (#24018)" (#24034)

This reverts commit 98c6910.

# Objective

@cart's
[objections](https://discord.com/channels/691052431525675048/749335865876021248/1499119335828881529):

1. I'm not sure top-level World methods for path-driven access is
justifiable in its current form. For anything but the smallest
application, looping over every Name in the app to find the one you're
looking for is pretty much never what you want
2. Calling Name::to_string() and collecting the result in a Vec isn't
going to cut it performance wise. Even within the scoped context of
entity access we shouldn't be doing any allocations or "recomputations".
Just the act of comparison across all entities is arguably too expensive

## Solution

Revert it for now and go back to revising the work before landing it.

## Plan going forward

[Core
plan](https://discord.com/channels/691052431525675048/749335865876021248/1499120012034838692):

1. An EntityRef API that is always relative to the current entity
2. Grab the Children component.
3. Iterate over it, read the Name on each component, see if it matches
the current piece of the path.
4. Add docs discouraging usage in most cases; users should prefer
`EntityTemplate` and pre-resolved connections.

As discussed
[here](https://discord.com/channels/691052431525675048/749335865876021248/1499120218927271987),
opt-in names indexing (both all names for inspector use cases and based
on With filters for e.g. animation) should be considered too, but
doesn't need to be in the MVP. @laundmo suggests the use of a trie,
while Sander says that a hashmap is adequate in flecs.

Author: alice-i-cecile

_release-content/release-notes/entity_path_resolving.md

@@ -8,7 +8,7 @@ use crate::{
     resource::Resource,
     world::{EntityWorldMut, Mut, World},
 };
-use alloc::{string::String, vec, vec::Vec};
+use alloc::{vec, vec::Vec};
 use variadics_please::all_tuples;
 
 /// A [`Template`] is something that, given a spawn context (target [`Entity`], [`World`], etc), can produce a [`Template::Output`].
@@ -405,8 +405,6 @@ pub trait SpecializeFromTemplate: Sized {}
 pub enum EntityTemplate {
     /// A reference to a specific [`Entity`]
     Entity(Entity),
-    /// A path to a specific [`Entity`]. Resolved via [`World::get_entity_from_path::<ChildOf, Name>`]
-    EntityPath(String),
     /// A reference to an entity via a [`ScopedEntityIndex`]
     ScopedEntityIndex(ScopedEntityIndex),
 }
@@ -437,25 +435,12 @@ impl From<Entity> for EntityTemplate {
     }
 }
 
-impl From<String> for EntityTemplate {
-    fn from(path: String) -> Self {
-        Self::EntityPath(path)
-    }
-}
-
-impl From<&'static str> for EntityTemplate {
-    fn from(path: &'static str) -> Self {
-        Self::EntityPath(path.into())
-    }
-}
-
 impl Template for EntityTemplate {
     type Output = Entity;
 
     fn build_template(&self, context: &mut TemplateContext) -> Result<Self::Output> {
         Ok(match self {
             Self::Entity(entity) => *entity,
-            Self::EntityPath(path) => context.entity.world().get_entity_from_path(path, None)?,
             Self::ScopedEntityIndex(scoped_entity_index) => {
                 context.get_scoped_entity(*scoped_entity_index)
             }
@@ -465,7 +450,6 @@ impl Template for EntityTemplate {
     fn clone_template(&self) -> Self {
         match self {
             Self::Entity(entity) => Self::Entity(*entity),
-            Self::EntityPath(path) => Self::EntityPath(path.clone()),
             Self::ScopedEntityIndex(scoped_entity_index) => {
                 Self::ScopedEntityIndex(*scoped_entity_index)
             }

crates/bevy_ecs/src/template.rs

@@ -1,6 +1,6 @@
 //! Contains error types returned by bevy's schedule.
 
-use alloc::{string::String, vec::Vec};
+use alloc::vec::Vec;
 use bevy_utils::prelude::DebugName;
 
 use crate::{
@@ -75,26 +75,6 @@ pub enum ResourceFetchError {
     NoResourceAccess(ComponentId),
 }
 
-/// An error returned when a path cannot be resolved.
-#[derive(thiserror::Error, Debug, Clone, PartialEq, Eq)]
-pub enum EntityPathError {
-    /// Path is empty
-    #[error("Entity path is empty")]
-    EmptyPath,
-    /// Root entity is not an ancestor of the starting entity
-    #[error("{0} is not an ancestor of {1}")]
-    RootIsNotAncestor(Entity, Entity),
-    /// One of the entities along the path does not contain a `Name` component
-    #[error("{0}, or one of it's ancestors does not contain a `Name` component")]
-    BrokenPath(Entity),
-    /// No paths match the given path
-    #[error("{0} does not match any entity")]
-    NoMatchingPath(String),
-    /// More than one paths match the given path
-    #[error("{0} matches multiple entities")]
-    AmbiguousPath(String),
-}
-
 #[cfg(test)]
 mod tests {
     use crate::{