Refactor Dismissable to not need a SizeObserver and to generally tighten
up the code a bit.

Rather than clamping _value on read, we now clamp the value when writing it,
which simplifies reasoning about _value.

We should mutate the status of the AnimationController before calling
the status callbacks so that we're prepared to be re-entered.

Fixes #1911

Move StepTween to tween.dart.

Move _buildIndicator() methods to be next to the build() methods they're
used from, so that reading the code is easier.

Fix typos, add some comments, style nits.

Each layer is supposed to reexport the parts of the previous layer
that are part of its API.

- In painting.dart, export from dart:ui all the Canvas-related APIs
  that make sense to be used at higher levels, e.g. PaintingStyle.

- Delete painting/shadows.dart. It was dead code.

- In rendering/object.dart, export all of painting.dart.

- In widgets/basic.dart, export all of painting.dart and
  animation.dart. Some classes in animation/ are renamed to make this
  less disruptive and confusing to the namespace.

- Split out Stocks back into an import model rather than a part model,
  so that it's easier to manage its dependencies on a per-file basis.

- Move Ticker to scheduler library.

- Remove as many redundant imports as possible now.

- Some minor nit picking cleanup in various files.

After the refactoring of the animation library, we were missing some
dartdoc.

When opening the keyboard or focusing an input widget, we should scroll the
widget into view so that the user can see what they're typing.

Previously this code was in the animation layer, which didn't make much
sense because scrolling is a widget concern.

These should be the last references to the old "performance" name.

Some of the Animation classes that we converted from performances use
the term "master" to refer to the animation upon which they're based.
This patch changes them to use the term "parent", which is consistent
with the rest of the animation classes.

Now that we've decided that Animation<double> isn't confined to the interval
0.0 to 1.0, we can expand AnimationController to cover the use cases that used
to require SimulationStepper.

This patch merges SimulationStepper into AnimationController and ports the one
stand-alone client of simulation stepper over to using AnimationController.

ClampedSimulation makes more sense at the newton layer because it's dealing
entirely with newton concepts.

This patch removes Performance and AnimationValue now that we've ported the
framework over to AnimationController and Tween. This patch also cleans up the
names of the AnimationController classes now that they don't have to avoid
conflicts with the old animation API. Specifically, I've made the following
renames:

 * Animated -> Animation
 * Evaluatable -> Animatable
 * PerformanceStatus -> AnimationStatus

This patch is just renames and moving code around. There aren't any changes in
behavior.

There should be no more uses of Performance or AnimatedValue in the framework
or the examples.

After this patch, there aren't any direct uses of Performance in material.dart.

This patch moves Navigator and related code over to using
AnimationController.

Also, clean up the class hierarchy for AnimationController now that
we've renamed progress to value. That means everything in the hierarchy
now has a value, include Watchable. This patch renames Watchable to
Animated<T>, which lets us use that type almost everywhere.

I've added some ducktape to modal bottom sheets to avoid having to
refactor all of Navigator to use AnimationController. I'll remove the
ducktape in the next patch.

These now use Animation and AnimationController instead of PerformanceView and
Performance.

The curve direction is now a concern of ACurve alone.

This patch removes state from the animation system, which was causing problems
as we were scaling the use of animated values.

Now the "tween" objects are stateless and can watch animations, which creates a
new object that holds both the tween and the animation instead of mutating the
tween every tick of the animation.

This patch ports one client as a proof-of-concept.

Fixes #215

How's this?

We had the units wrong on the tolerances. Previously we multiplied by the
device pixel ratio, which meant we got larger tolerances as we got more
resolution. Also, simplify logic in Newton for applying the tolerances.

Fixes #828

The same as AlwaysCompletePerformance but the exact opposite.

Also, replace places that use the term "create performance" with
"create performance controller".

Primarily, this rearranges how listeners are handled internally by the
various PerformanceView classes so that there's not so much redundancy.

It also fixes ReversePerformance and ProxyPerformance to not leak.
Previously, they never unhooked their listeners, so they'd leak until
the entire chain of performances was killed. Now, they unhook as soon as
they themselves have no listeners left, which is more idiomatic.

For those times when you want to do something as you move away from a
route into the next one, as well as when you move into it from the
previous one.

The names are probably less familiar, but more consistent:
- FrameCallback: a callback that is relative to the frame and wants the
  frame offset (a duration) as argument.
- addXFrameCallback: adds the given callback to the internal lists/maps.
- scheduleXFrameCallback (currently only X = ""): add the callback, but
  also trigger a new frame.
- handleX: the method that is invoked when the event-loop or the frame
  calls into the scheduler.
- ensureXYZ: ensure that the callback happens.
  Unfortunately there is the ambiguity between a "callback": it can be a
  closure, or the action of doing a callback, so we end up with:
  ensureBeginFrameCallback, and ensureEventLoopCallback, where
  "callback" means the action of being called back.