Unnecessary injection into scope where functions refer to other functions in same block but not same scope

[overlookmotel]

Input:

function outer(ext) {
  let other = (0, () => ext);
  const inner = (0, () => other);
  const setOther = v => other = v;
  return { inner, other, setOther };
}

const { inner, setOther } = outer(1);
const { other } = outer(2);
setOther(other);
export default inner;

Output:

const createScopeOuter = (other, ext) => [
    _other => other = _other,
    () => ext,
    () => other
  ],
  scopeOuter = createScopeOuter();
scopeOuter[0]( createScopeOuter(void 0, 2)[1] );
export default scopeOuter[2];

other from 2nd scope is injected into first scope. This is unnecessary. Output could be shorter:

const createScopeOuter = (other, ext) => [
    () => ext,
    () => other
  ];
export default createScopeOuter( createScopeOuter(void 0, 2)[0] )[1];

This inefficient output is caused by a4c86d7 which was solution to #226.

[overlookmotel]

Fixing this would require a complicated analysis to detect circularity.

Two-phase serialization (as discussed in #169 (comment)) would make these cases easier to identify.

[overlookmotel]

Two-phase serialization now has its own issue: #426