Support using global variables inside a function's body

Previously, we did not support using global variables inside a function's body:

        x = 1
        def sum(y):
            return x + y
        sum(y)

The above would break since sum is using a variable that's defined outside the function's body. If a user tried to refactor a notebook with code like this using Soorgeon refactor, they would get an error message asking them to change the code to:

        x = 1
        def sum(y, x):
            return x + y
        sum(y, x)

This PR automate this process and modify the user's source code on their behalf so they don't have to do it manually.

https://github.com/ploomber/soorgeon/issues/65

Closes #65

Checklist before requesting a review

[ x] I have performed a self-review of my code
[ x] I have added thorough tests (when necessary).
[ ] I have added the right documentation (when needed). Product update? If yes, write one line about this update.

Need advice on these issues:

class methods:

Currently, Soorgeon detect globals in functions but not in class methods.
Do we also need to detect & fix globals inside class methods?
Issue 26 may be related
If yes, I should probably create a new issue & another PR just for that, because the detection logic is code I haven't touch, & would be easier to understand if we keep them separate.
Reminder: detection logic is in export.py in find_inputs_and_outputs.

Nested function definitions:

Apparently no one has ever use Soorgeon with a notebook with nested function definitions because it would throw an InputWontRunError for undefined name when calling the nested function. Example:
```
def fn():
    def nested():
        return global1
    return nested()
```

Would throw an error: undefined name nested. Apparently is a known limitation of pyflakes. In export.py, if we comment out the line pyflakes.check_notebook(self._nb), we don't get that error, but the code won't be checked by pyflakes.

In the unlikely case that that we eliminate pyflakes & do not throw an error on nested functions, we would need to revisit the fix_global functionality, because currently it would include the nested function name, in the outer function parameters.
We would also need to consider the case when the outer function was fixed, & now it's parameters contain the global variable, would the inner function also need to be fixed?

Integration tests are failing:

I think it has nothing to do with this PR.
Somehow it was passing before, but now pytest can not find the tests. I have done research & experiments but unable to find a solution

ploomber / soorgeon