Fixes #4679

Basically what happens is that when we encounter a fragment we unwrap it to return is children, this way when elements get wrapped with fragments we don't risk losing state in between renders.

This has a consequence when it is used in hooks environments as a hook with a closure will capture the outer scope. As can be seen in the reproduction, if an effect (or any other hook) closure takes a snapshot of the outer closure it will take the Fragment we unwrap into memory, this means that during diff we'll effectively start mutating its children. Note that it's important that the hook has no dependencies for this to be reproduced.

Every time we re-render we'll take a new snapshot of the closure which retains a copy of Fragment with pointers to all of its populated children. We unwrap the Fragment which still points at its children which point back at the parent of the Fragment. The closure points at the Fragment, the Fragment points at its children (props.children) and the children point at the parent component of Fragment.

With the implemented measure we clear props.children of the Fragment so that we effectively break this chain of pointers and allow the Fragment to be gc'd in-between renders caused by updates to the same component.

Fun fact, when we implement #4679's reproduction with class components there is no memory leak, this was one of the first pointers to me that hooks and their closures were the culprit.