Tag helpers registration system

- This registration system accepts tag descriptors that it then uses to feed requests for tag helpers.
- Added some infrastructure pieces that are used to build up valid tag helper descriptors.

#70
if the ability to use variables and expressions for any and all tag helper attributes does not exist in v1, let's delay shipping anything.  the tag helper feature won't be usable or interesting if we can't at least do what's possible with `@Html.TextBoxFor()`, `<element attribute="@value" />`, and so on today.
we can probably get away without IntelliSense: users don't get IntelliSense when they're in attributes today.  for example, `<div id="@Html.IdFor(...)" ... />` provides IntelliSense for the "id" attribute but not for "Html", "IdFor", etc.

separately, this class as a whole is contradictory.  on one hand, it doesn't support anything without a single-parameter constructor.  on the other, it seems to focus on `TagHelperExpression` and that won't have a single-parameter constructor.  (we couldn't write such a constructor without exposing both `TModel` and `TValue` directly in the type tag helper authors use.)
my expectation is we'll have methods in `RazorPage<TModel>` or a provider accessible to `RazorPage<TModel>` with signatures like `object GetTagHelper(TagHelperDescriptor descriptor)` (may be fine to pass a tag helper name or descriptor id instead -- easier to generate code for) and `TagHelperExpression GetTagHelperExpression<TValue>(Expression<Func<TModel, TValue> expression)`.  the generated code might look like
``` c#
  var tagHelper = ({tag helper type name from descriptor})GetTagHelper(descriptor);
  tagHelper.OneStringProperty = "{some user-entered non-expression}";
  tagHelper.AnotherStringProperty = {whatever the user typed, less the '@' which switched to this mode};
  tagHelper.IntProperty = {whatever the user typed};
  tagHelper.ComplexProperty = {whatever the user typed};
  // Following alternatives wouldn't both be used for one tag helper.  No use cases for multiple THEs per tag helper.
  tagHelper.ExpressionProperty = GetTagHelperExpression((m) => m.{whatever the user typed});
  tagHelper.ExpresisonProperty = GetTagHelperExpression((m) => {whatever the user typed, less the '@' which switched to this mode});
  TagHelperManager.DoWhatIMean(tagHelper);
```
The above would provide exactly the right IntelliSense if the user were typing in the generated file.  It avoids any differentiation between tag helper properties of all types except `char`, `string`, and `TagHelperExpression`.
This also makes special-casing those rare `TagHelperExpression<bool>` (or whatever concrete type) cases as simple as including a `TagHelperExpression<bool> GetTagHelperExpression(Expression<Func<TModel, bool>>)`.  But that's a derivative case and I think we'll be fine supporting only base `TagHelperExpression` properties in the first go-round.