Functional JIT loading closures sharp edge

Nobody has claimed this yet.

## Strategy required

This issue resumes form PR2410, we need to decide on the strategy for closures sharp edge. Let's start simple, I think we can all agree that this is a sharp edge if we jit `foo`:

``` python
x = 5
def foo():
return x
```

And that's because we are using a variable outside of the jitted scope. However, here is where things get interesting: should we consider the following a sharp egde?

``` python
def foo(x):
def bar():
return x
return bar()
```
I assume that, since we captured x when jitting `foo`, this should not be a sharp edge for `bar` because the variable was declared in the scope(or in this case captured). To fix such a case we can remember what variables we captured and then look them up when we see a freevar. However, @mruberry has an interesting point, what happens in the case that the variable gets deleted? How can we deal with something like:

``` python
def foo():
a = 5

def bar():
nonlocal a
del a

bar()

return a
```
In conclusion, what do you think should be the definition of sharp edge in this context?

cc @apaz-cli @t-vi @mruberry

Start by reviewing PR2410 and the three closure examples in this issue. Compare how jitted functions handle free variables, captured variables, and deleted nonlocal variables, then document an agreed definition of this sharp edge and the strategy for addressing it.

Written by the indexing model from the issue text.