compilation enviroments are always modules; simplifications & refactorings

* module/ice-9/boot-9.scm (make-fresh-user-module): New public function,
  makes an anonymous beautified module.

* module/language/objcode/spec.scm: We used to have some things in here
  that allowed lexical variable names and values to be a part of the
  environment, but no more. Now an environment is just a module. If you
  want to "inject" free variables into code, just use lambda.

* module/language/scheme/compile-tree-il.scm (compile-tree-il): Same
  here. Also, rely on the fact that an environment *will* be a module --
  because (system base compile) guarantees that for us.

* module/language/scheme/spec.scm (scheme): In the reader, rely on the
  environment being a module. Define a #:make-default-environment
  handler, which returns a beautified module, augmented with a fresh
  definition for current-reader, so that side effects to current-reader
  are restricted to the compilation unit.

* module/language/tree-il/analyze.scm
  (report-possibly-unbound-variables):
* module/language/tree-il/compile-glil.scm (compile-glil):
* module/language/tree-il/optimize.scm (optimize!): The environment will
  be a module.

* module/system/base/language.scm (<language>): New field,
  `make-default-environment'. Defaults to `make-fresh-user-module'.
  (default-environment): New accessor, returns a default environment for
  a language.

* module/system/repl/common.scm (repl-compile): Always compile relative
  to the current module, because a module is always acceptable as an
  environment.

* module/system/base/compile.scm (compile-file, compile-and-load): Both
  of these have a new keyword argument, #:env. For `compile-file', it
  defaults to the default environment of the source language, and for
  `compile-and-load', to the current module.
  (read-and-compile): If there are no expressions read, pass the joiner
  its default environment (via `default-environment joint').

module/system/base/compile.scm

@@ -141,9 +141,9 @@
 
 (define* (compile-file file #:key
                        (output-file #f)
-                       (env #f)
                        (from (current-language))
                        (to 'objcode)
+                       (env (default-environment from))
                        (opts '()))
   (let* ((comp (or output-file (compiled-file-name file)))
          (in (open-input-file file))
@@ -159,10 +159,11 @@
       file)
     comp))
 
-(define* (compile-and-load file #:key (from 'scheme) (to 'value) (opts '()))
+(define* (compile-and-load file #:key (from 'scheme) (to 'value)
+                           (env (current-module)) (opts '()))
   (read-and-compile (open-input-file file)
                     #:from from #:to to #:opts opts
-                    #:env (current-module)))
+                    #:env env))
 
 
 ;;;
@@ -191,33 +192,10 @@
           (else
            (lp (cdr in) (caar in))))))
 
-(define (make-compilation-module)
-  "Return a fresh module to be used as the compilation environment."
-
-  ;; Ideally we'd duplicate the whole module hierarchy so that `set!',
-  ;; `fluid-set!', etc. don't have any effect in the current environment.
-
-  (let ((m (make-module)))
-    (beautify-user-module! m)
-
-    ;; Provide a separate `current-reader' fluid so that the Scheme language
-    ;; reader doesn't get to see the REPL's settings for `current-reader',
-    ;; which would lead to an infinite loop.
-    (module-define! m 'current-reader (make-fluid))
-
-    m))
-
-(define (language-default-environment lang)
-  "Return the default compilation environment for source language LANG."
-  (if (or (eq? lang 'scheme)
-          (eq? lang (lookup-language 'scheme)))
-      (make-compilation-module)
-      #f))
-
 (define* (read-and-compile port #:key
                            (from (current-language))
                            (to 'objcode)
-                           (env (language-default-environment from))
+                           (env (default-environment from))
                            (opts '()))
   (let ((from (ensure-language from))
         (to (ensure-language to)))
@@ -227,10 +205,11 @@
           (let ((x ((language-reader (current-language)) port cenv)))
             (cond
              ((eof-object? x)
-              ;; FIXME: what if there are no expressions to be read?
-              ;; then env is #f. Here default to cenv in that case.
               (compile ((language-joiner joint) (reverse exps) env)
-                       #:from joint #:to to #:env (or env cenv) #:opts opts))
+                       #:from joint #:to to
+                       ;; env can be false if no expressions were read.
+                       #:env (or env (default-environment joint))
+                       #:opts opts))
              (else
               ;; compile-fold instead of compile so we get the env too
               (receive (jexp jenv jcenv)
@@ -241,7 +220,7 @@
 (define* (compile x #:key
                   (from (current-language))
                   (to 'value)
-                  (env (language-default-environment from))
+                  (env (default-environment from))
                   (opts '()))
 
   (let ((warnings (memq #:warnings opts)))