Change `Delay` into `Delay<T>`, and add support for raising a completion
event or callback.

Bug: #69

Fix registration of the `component_animator_system::<Text>` in the
`TweeningPlugin` to depend on the new `bevy_text` feature, and not on
the `bevy_ui` one.

Ensure change detection on components and assets is only triggered when
an animator effectively modifies said component or asset, and not
invariably just by the simple fact of the animator ticking each frame.

This change modifies the signature of the `component_animator_system()`
and `asset_animator_system()` public functions to directly consume a
`ResMut<Events<TweenCompleted>>` instead of an
`EventWriter<TweenCompleted>`, to work around some internal limitations.

It also publicly exposes a new `Targetable` trait used to work around
the impossibility to retrieve a `Mut<T>` from a `Mut<Assets<T>>`.
Instead, the trait provides an "target dereferencing" method
`target_mut()` which dereferences the target component or asset, and
triggers its change detection. The trait is implemented for all
components via the `ComponentTarget` object, and for all assets via the
`AssetTarget` object. The 3 types described here are publicly exposed to
workaround some Bevy limitations, and because the trait appears in the
public `Tweenable<T>` API. However users are discouraged from taking
strong dependencies on those, as they will be removed once Bevy provides
a way to achieve this conditionaly dereferencing without this
workaround.

Fixes #33

Fix the animator speed applying, which got broken as part of the
refactor of #44.

Add a `speed()` getter to both `Animator<T>` and `AssetAnimator<T>`.

Add some simple test for speed, but this is not enough to make sure the
feature doesn't regress, so logged #62 to follow-up with a proper
regression test.

Fixes #61

Upgrade to the latest released version 0.8.0 of Bevy.

Add a new `bevy_asset` feature to enable animation of Bevy assets
(types implementing the `Asset` trait). Bevy 0.8 does not contain
`bevy_asset` in its defaul features, so this new feature reflects that
new possibility to build Bevy and í½ƒ Bevy Tweening without support
for the `bevy_asset` crate. The new feature is enabled by default for
discoverability and to prevent a behavior breaking change.

This lets you not have to run after every single system and instead just pass in the label.

It needs to be built-in because otherwise you have to completely recreate the animation to change the speed.

Enable minimal dependencies with new features `bevu_sprite` and
`bevy_ui`, removing the `bevy/render` mandatory dependency. Those new
features are enabled by default, and enable the built-in lenses for the
related Bevy crates. The core `bevy_tweening` crate itself does not take
any optional Bevy dependency anymore, allowing for a slim build with
only the core Bevy functionalities.

Update all links to Bevy docs to point to v0.6.1, and add to `README.md`
the missing predefined rotation lenses.

Add a mechanism to `Tween<T>` to raise a Bevy event once the tween
completed. The event raising can be enabled with `set_completed_event()`
and `with_completed_event()`. The `TweenCompleted` event contains the
`Entity` on which the `Animator<T>` or `AssetAnimator<T>` owning the
tween are attached.

Update the `sequence` example to show how to use that new event
mechanism.

Provide the callback owner with the `Entity` the tween and the animator
are attached to, as a parameter to the callback when invoked.

Add some new methods and refactor some existing ones to clarify the
playback state of a tweenable, and give increased control to the
`Animator` or `AssetAnimator` to rewind a tweenable, set its progress to
an arbitrary value, or query its current state.

Add a `Tweenable<T>` trait describing a generic animatable tween-like
element.

Expose the three types of tweenables and implement `Tweenable<T>` for
them:
- `Tween<T>`, a single animation
- `Sequence<T>`, a sequence of consecutive animations
- `Tracks<T>`, a batch of animations running in parallel

Clean-up animators to hold a single top-level `Tweenable<T>` and let the
user build any kind of animation hierarchy for themselves.

Allow querying the active tween of a sequence. Use this to improve the
`sequence` example with some text showing the current active tween and
its progress.

Implement some callbacks invoked when a tween anim starts or ends.

Export publicly the asset and component system to allow an app to
manually add them.

- Add `Sequence<T>` for chained tweens
- Add `Tracks<T>` for tracks of sequences running in parallel
- Move most animation-related properties to the new `Tweens<T>` struct
- Add `sequence` example

Import `bevy_tweening` from its old repository.

URL:
https://github.com/djeedai/bevy_extra/tree/main/crates/bevy_tweening

Commit: 1e13a72