Switch to using createFactory in compiler steps

```js var Foo = require('Foo'); function Bar() { return <Foo x={1}>Hi</Foo>; } ``` Originally we intended to compile JSX to this format: ```js var Foo = require('Foo'); var Foo_ = React.createFactory(Foo); function Bar() { return Foo_({ x: 1, children: "Hi" }); } ``` That allows us to generate a factory that can be more optimized and resolves `defaultProps`. There are some problems with generating an optimized factory in many cases because it can slow down start up. However, if you have an optimizing compiler that can resolve that, we can turn that on in those cases. Another thing we can do is that if the function is a simple functional component then we can just return the functional component itself. So that it becomes just a straight through function call. At least if the element doesn't have a key. (Slight change in semantics but mostly not.) An optimizing compiler or VM (that is aware of the type of "Foo" which not known to the Babel transform) can then infer that this function is just a function call and can then proceed to actually inline it. For heavy functions it would be bad to do this though since it can expand the time a render is executed and work against the time slicing mechanism of Fiber. Therefore, we might want to use a heuristic to determine if a functional component gets to be "inlined" or not. E.g. function length or something. A good data point to use in a heuristic is whether the component is part of a loop or a closure (such as being part of a map); ```js var Foo = require('Foo'); function Bar({ data }) { var children = []; for (var i = 0; i < data.length; i++) { children.push(<Baz>{data[i]}</Baz>); } return <Foo x={1}>{children}</Foo>; } ``` or ```js var Foo = require('Foo'); function Bar({ data }) { return <Foo x={1}>{data.map(d => <Baz>{d}</Baz>)}</Foo>; } ``` We could change the transform to treat these special and flag them as part of a hot path by calling a special createFactory: ```js var Foo = require('Foo'); var Baz…