Q1: What does this resolve to:

    foo(arg)

   It could be:
   1. this.foo(arg)
   2. EnclosingClass.foo(arg) // i.e. a static method call
   3. a call to a top-level function foo()

If we adopt the idea that a module is just a class definition (with some
syntactic differences) and classes can be nested, then 3 really means "a call
to a static method on the class surrounding the enclosing class".

I *don't* think we want the answer to the question to vary based on the name
in question. We can't rely on name resolution to disambiguate because we don't
know the full set of surrounding names in a single pass compiler. Also, it's
semantically squishier.

I think the right answer is 1, it's an implicit call on this. That's what you
want most often, I think. For imported modules, we could import them with a
"prefix" (really import them as objects bound to named variables), so calling
a top-level function in another module would be something like:

  someModule.foo(arg)

This leaves the question of how *do* you call top level functions in your own
module? I.e., how do we call foo here:

  def foo(arg) { IO.write("called foo!") }

  class SomeClass {
    bar {
      // Want to call foo here...
    }
  }

This is analogous to:

  class SomeModule {
    static foo(arg) { IO.write("called foo!") }

    class SomeClass {
      bar {
        // Want to call foo here...
      }
    }
  }

The obvious solution is to use the class name:

  class SomeModule {
    static foo(arg) { IO.print("called foo!") }

    class SomeClass {
      bar {
        SomeModule.foo(arg)
      }
    }
  }

Which just leaves the question of what the class name of a top-level "module
class" is.

Idea: it's unnamed, so you just use a leading ".":

  def foo(arg) { IO.print("called foo!") }

  class SomeClass {
    bar {
      .foo(arg)
    }
  }

This mirrors C++'s unnamed scope thing:

  ::foo(arg);