1. lexically contained closures will return since it knows it is safe to do so (e.g. nonlocal -> local return conversion)
  2. other closures will copy to the return value of the method and jump to the end of the method

I believe #2 is wrong and it is not currently possible to hit with the limitations in what we will inline.  I still added it as it seemed like some code should be there to handle this scenario when/if we decide to support it.  I think the premise of what #2 does is right; but I do not see how we can guarantee where we jump to could possibly have the same variable in a return instr (or copy to some other significant variable).

For posterity, if I delete #1 and run the following script I feel this should still work but it doesn't:

```ruby
def try_fdopen()
  1.times do
    return :exit_closure
  end
  :exit_try_fdopen
end


def foo
  i = 0
  while i < 1000 do
    p try_fdopen
    i += 1
  end
end


foo
```

implement Enumerable#tally