De-dupe JSX elements when serializing

[NTillmann]

The identity of React elements (objects with a properly configured $$typeof property) is immaterial.
We can therefore identify structurally equivalent react elements, ultimately resulting in improved code density.
Action plan:

1. Rewrite the heap to identify structurally equivalent react elements, e.g. in the ResidualHeapVisitor, by maintaining a new HashSet containing wrapper objects around react elements that implement a structural getHash and equals.
   (Note that as a result, a react element may now appear in multiple scopes.)
2. For children of react elements, the serializer currently has a special treatment in _serializeValueReactElementChild: it bypasses the regular logic of serializeValue that hands out names to values and selects the proper target body. This needs to get revisited. One approach would be to just fall back to the regular code path. This would result in aesthetically displeasing code, unless the option --inlineExpressions is given; however, when combined with an JavaScript compiler that produces bytecode, the resulting bytecode is likely the same even without --inlineExpressions.

The reason _serializeValueReactElementChild currently does what it does is to add keys to array elements. However, @trueadm has a plan how to switch from arrays to fragments which no longer have that requirement. We'll probably need that first.

[trueadm]

One constraint to add, if the JSX attribute of key is a StringValue we cannot add these de-dupe optimizations to that React element as this depends on React runtime constraint. Check this issue for prior discussions on this topic: facebook/react#3226

So this can be optimized:

function MyComponent() {
  return (
    <div>
      <span />
      <span />
      <span />
      <span />
    </div>
  );
}

To be:

const __a = <span />;
const __b = <div>{__a}{__a}{__a}{__a}</div>;

function MyComponent() {
  return __b;
}

If a React element has a key, we will also need to preserve that. For example:

function MyComponent() {
  return [<div key="a" />, <div key="b" />, <div key="c" />, <div key="d" />];
}

We can't hoist those nodes reliably, one way we could optimize this could be:

__div(key) {
  return <div key={key} />
}
function MyComponent() {
  return [__div(a), __div(b), __div(c), __div(d)];
}

[trueadm]

A bunch of these use-cases should be covered by the PR: #1196