This PR combines an alternate approach to implementing Context to#995 and also the move to react-testing-library (#996) because testing React context with enzyme isn't yet possible. The PR does the following:

• implements context and subscriptions via React'sReact.createContext()
• adds support for refs directly viaReact.forwardRef
• allows multiple children in the Provider component
• allows changing the store prop in Provider (for hot reloading, or switching out for a new store)
• allow nested Providers, the lowest provider in the tree controls children below it (feature of React context, not react-redux)
• replaces passing store as prop by passing custom context provider to<Provider> and context consumer to connected components:

functionComp(props){return<div>{props.hi}</div>}constContainer=connect(...)(Comp)constcustomContext=React.createContext()functionFancyPants(){return(<Providerstore={store1}>      Primary provider<Providerstore={store2}context={customContext.Provider}><Container>          Uses store 1<Container>            Also uses store 1<Containerconsumer={customContext.Consumer}>              Uses store 2<Container/> <!-- this uses store 1 again --></Container></Container</Container></Provider></Provider>)}

• it reduces code size by almost 25% (drops 80 lines)
• removing subscriptions greatly reduces maintenance complexity
• no usage ofgetDerivedStateFromProps, instead, derived props are memoized inrender()
• more async-ready because all subscribing is done incomponentDidMount andcomponentDidUpdate of theProvider component, subscriptions are not handled at all in connected components, except to read from React's context consumer. This doesn't address tearing and other async issues that are caused by redux being synchronous in nature. Fixing this will require breaking redux's backwards compatibility, and that's a different discussion.
• probably more hot loader compatible, again because subscriptions are isolated inProvider and handled by React context.
• Tests: removes testing in React prior to 16.4, ups dependencies to React 16.4+, adds react-testing-library dependency, removing enzyme and react-test-renderer deps. It preserves the multi-version testing framework, in order to add new React versions for testing as they are released. Several tests are updated to support the backwards-compatibility breaks

Drawbacks to this approach:

• BC break:withRef is gone for connected components. The code errors out explaining that the user should simply pass a ref in and it will work. This will cause codebases to break that are relying on withRef. Fortunately, the fix is to remove withRef and update code to use standard reference handling procedures in React. docs need to be updated
• BC break:store cannot be passed as a prop to connected components. The code errors if a user attempts to pass store to a connected component. The error explains to use a customProvider (as noted above) to fix this, but will cause breaks in the few programs using this feature. docs need to be updated
• BC break:storeKey is irrelevant inconnect() options. The code errors if a user attempts to pass this option inconnect()'s options. The error explains to simply use a nestedProvider or a customProvider. docs need to be updated
• requires 3 wrapper components,Connect, the Context consumer, andPureComponent wrapper around the component in pure mode (2 in impure mode). This is what makes the simplicity possible. The top-most component retrieves the context containing redux state, calculates derived props, and passes them to the inner component. Rather than try to do all of this beforeshouldComponentUpdate, which leads to tons of complexity and brittle code, we pass it to the underlying component. sCU inPureComponent works perfectly for our needs, preventing update if the derivedProps are unchanged.
• in order to support forwardRef, we have to importreact-is, which does not yet have an esm build, so we gain a little heft in exchange for the reduction in code
• the existing hot loading tests don't work at all, and had to be stripped. The implementation assumes that when hot loading, we may get passed a new store to Provider, which will require unsubscribing from the old and subscribing to the new in componentDidUpdate, but this is not tested in the real world yet. There are tests for this new behavior inProvider.spec.js
• because tests didn't work at all, the diff is huge.

@markerikson@timdorr