...instead of a deep walk.

That way folks can customize it if they want (and it makes the code a
bit more self-documenting).

Now the label animates from its inline position to above the text and
the focus highlight grows into place.

RawEditableLine is now responsible for the scrolling behavior, which
removes the need for callbacks between RawEditableLine and Input. It
also fixes a bug whereby the whole Input widget (including its icon)
would scroll when the text got long.

Properly support labels, hints, icons, and custom typography.

This reverts commit ab300634.

Fixes #1308

This patch restructures how we size the editing region of the Input widget. Now
RenderEditableLine understands that it's a single-line editing widget and sizes
itself correctly.

Now you can colorize an Icon simply by proving a Color for the Icon.

Third-party libraries can now provide their own mojo services. They do
so by adding a config.yaml file to their pub package which contains
- a list of service names and java classes which handles that service's
  registration.
- a list of pre-built .jar files to statically link with the app's shell
  when building the app.

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.

Instead, require the developer to opt-in to autofocusing because autofocusing
can be disruptive.

Fixes #1307

The space for the keyboard is now represented as bottom padding for the window.
By teaching the scaffold to respect the bottom window padding, we move the
floating action button and snackbars out of the way of the keyboard.

This currently works on Android. I'll need to see how to get the keyboard
geometry on iOS for a similar effect.

Fixes #103

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.

I've left transitions and enter_exit_transition out of this patch, but I've
converted the rest.

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

Providing a pre-built child is more efficient because we don't need to rebuild
the child every tick of the animation.

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