…few more of its bindings, by marking them as two-way.

Some of knockout's built-in bindings (checked, hasFocus, selectedOptions, textInput, and value) are already listed as "two-way bindings" by default. For these, knockout generates an additional binding named "_ko_property_writers" which exposes functions for writing these values to non-observable model properties.

We need to tell knockout to generate property writers for more of its built-in bindings, so that `init` can use these to write to the model.

…r that generates custom property writers.

Knockout's _twoWayBindings collection only covers basic `name: value` bindings.
For more complex bindings that receive an object literal (including KO's own "attr"), we need to generate property writers ourselves.

…n-observable model properties.

This commit expands on the existing logic of finding and invoking fieldAccessors. But if no fieldAccessor is found, or it is not observable, then look for a suitable property writer instead.

…in arrays, and also subscribe to changes in a knockout-es5 tracked array property.

The trickiest part of this commit is setting up the subscription with change tracking. When the array comes from a knockout-es5 "tracked" model, it is actually being read from an ES5 property getter which reads from an internal observableArray. But we don't have access to that underlying observableArray here, so we can't call `array.subscribe(..., "arrayChange")`.

Instead, we take advantage of Knockout's dependency tracking and set up a `ko.computed` which reads the array from `valueAccessor()`. This sets up a dependency such that the body of our `computed` will be invoked any time the array changes. This works regardless of whether the model uses an actual observableArray or a ko-es5 tracked array property.

Since we can no longer reliably subscribe to the "arrayChange" notification to get the diffs, we need to take on a bit of that responsibility ourselves (basically doing the same as what KO would do if we did subscribe).  We keep track of the previous array contents, and then use `ko.utils.compareArrays` to get the differences.

(I had to move the biniding's `init` logic into the `InitializedForEach` constructor so that the `ko.computed` could use the `valueAccessor()`)

   * Added knockout-es5 package - This is only required for test and some examples, but is entirely optional when using knockout-pre-render.
   * Added tests against plain JS models.
   * Added tests against knockout-es5 tracked models

   * Example that populates a plain JS model.
   * Example that populates a knockout-es5 model

   * If the incoming data is observable, subscribe to its changes the normal (simpler) way.
   * If it's *not* observable, then use the "computed" approach with explicit change tracking.

This avoids redundant change tracking in the case the observableArray has multiple subscribers to the 'arrayChange' notification.

   * Removed unnecessary parens around some boolean expressions.
   * Fixed an error in a comment.