First draft of puzzler candidate 'Oddly Enough'

@nermin You'll recognize this one ;-)
> Rather, it has to return from a real method, so it has to somehow jump from the generated apply method into the 
> innermost enclosing method.

I think that's exactly what I am trying to say, but I'm obviously not phrasing it clearly ;-) What I am trying to get at is that if you have something like:
```
def enclMethod(): Int = {
  val genInt = () => return 42
  genInt() + 1
}
```
it may _look_ as though the compiler should just be able to use a JVM return, because you may not immediately see the "real" enclosing method (i.e. the `apply` method) that is created at the JVM level. But because the above actually compiles to something like:
```
scala.Int enclMethod() {
  private Function<scala.Unit, scala.Int> genInt = new Function<scala.Unit, scala.Int>() {
    public scala.Int apply() {
      // can't use return here as that would not jump to enclMethod, but simply exit the apply method!
    }
  }
  return genInt.apply() + 1;
}
```
a JVM return would not work, because it "would return from the `apply` method that is generated for the function body, rather than jumping to the innermost enclosing named method or function in the program".

So I think we're saying the same thing, but it needs to be reformulated to make it clearer?