Allow to mutably query for immutable components

[vil-mo]

What problem does this solve or what need does it fill?

Related #17140

Often you want to lock end users from mutating component, while still having the ability to mutate it in the library internals. For example there is a Child and Parent relationship in the bevy_hierarchy #16662

Currently, this access only limited to the exclusive world access. Querying also can be an option

What solution would you like?

There are two ways of implementing it:
Add new smart pointer analogue to Mut that implements QueryData and only allows getting mutable access via unsafe methods

impl<'a, T> AssumeMut<'a, T> {
    /// - One of the following should be true:
    ///   - Either `T` is mutable, or
    ///   - `OnReplace` hooks and observers for that component on that entity should trigger immediately before the mutation
    ///     and `OnInsert` should trigger immediately after the mutation, or
    ///   - The user should uphold documented invariants of `T`. If no such documentation provided, it is impossible for the end user to uphold this.
    unsafe fn assume_mut(self) -> Mut<'a, T> {
        // ....
    }
}

Or

Change Mut smart pointer in a way to add assume_mut function if the type it points to is immutable.

impl<T> Mut<'_, T> {
    /// - One of the following should be true:
    ///   - Either `T` is mutable, or
    ///   - `OnReplace` hooks and observers for that component on that entity should trigger immediately before the mutation
    ///     and `OnInsert` should trigger immediately after the mutation, or
    ///   - The user should uphold documented invariants of `T`. If no such documentation provided, it is impossible for the end user to uphold this.
    unsafe fn assume_mut(&mut self) -> &mut T {
        // ....
    }
}

For that current implementation of immutable components does not work, since Mut is generic over any type, but DerefMut only should be implemented for mutable components. For that we can either

trait Mutable {}

impl<T: Mutable> DerefMut for Mut<'_, T> { /*..*/ }

Or

trait Mutability {
    type Mutability: ComponentMutability; // Rename would be desired
}

trait Component: Mutability { 
    // No associated `Mutability` type
    //...
}

impl<T: Mutability<Mutability = Mutable>> DerefMut for Mut<'_, T> { /*...*/ }