really boot primitive-eval from scheme.

* libguile/eval.c (scm_primitive_eval, scm_c_primitive_eval):
  (scm_init_eval): Rework so that scm_primitive_eval always calls out to
  the primitive-eval variable. The previous definition is the default
  value, which is probably overridden by scm_init_eval_in_scheme.

* libguile/init.c (scm_i_init_guile): Move ports and load-path up, so we
  can debug when initing eval. Call scm_init_eval_in_scheme. Awesome.

* libguile/load.h:
* libguile/load.c (scm_init_eval_in_scheme): New procedure, loads up
  ice-9/eval.scm to replace the primitive-eval definition, if everything
  is there and up-to-date.

* libguile/modules.c (scm_module_transformer): Export to Scheme, so it's
  there for eval.go.

* module/ice-9/boot-9.scm: No need to define module-transformer.

* module/ice-9/eval.scm (capture-env): Only reference the-root-module if
  modules are booted.
  (primitive-eval): Inline a definition for identity. Throw a more
  standard error for "wrong number of arguments".

* module/ice-9/psyntax.scm (chi-install-global): The macro binding for a
  syncase macro is now a pair: the transformer, and the module that was
  current when the transformer was installed. The latter is used for
  hygiene purposes, replacing the use of procedure-module, which didn't
  work with the interpreter's shared-code closures.
  (chi-macro): Adapt for the binding being a pair, and get the hygiene
  from the cdr.
  (eval-local-transformer): Adapt to new form of macro bindings.

* module/ice-9/psyntax-pp.scm: Regenerated.

* .gitignore: Ignore eval.go.stamp.

* module/Makefile.am: Reorder for fastest serial compilation, now that
  there are no ordering constraints. I did a number of experiments here
  and this seems to be the best; but the bulk of the time is compiling
  psyntax-pp.scm with eval.scm. Not so great.

* libguile/vm-engine.c (vm-engine): Throw a more standard error for
  "wrong type to apply".

* test-suite/tests/gc.test ("gc"): Remove a hack that shouldn't affect
  the new evaluator, and throw in another (gc) for good measure.

* test-suite/tests/goops.test ("defining classes"):
* test-suite/tests/hooks.test (proc1): We can't currently check what the
  arity is of a closure made by eval.scm -- or more accurately all
  closures have 0 required args and no rest args. So punt for now.

* test-suite/tests/syntax.test ("letrec"): The scheme evaluator can't
  check that a variable is unbound, currently; perhaps the full "fixing
  letrec" expansion could fix this. But barring that, punt.

module/ice-9/psyntax.scm

@@ -1055,12 +1055,33 @@
                           '())
                          (build-data no-source name)))
                   (build-data no-source 'macro)
-                  e))
+                  (build-application
+                   no-source
+                   (build-primref no-source 'cons)
+                   (list e
+                         (build-application
+                          no-source
+                          (build-primref no-source 'module-name)
+                          (list (build-application
+                                 no-source
+                                 (build-primref no-source 'current-module)
+                                 '())))))))
            (build-application
             no-source
             (build-primref no-source 'make-syncase-macro)
-            (list (build-data no-source 'macro) e))))))
-
+            (list (build-data no-source 'macro)
+                  (build-application
+                   no-source
+                   (build-primref no-source 'cons)
+                   (list e
+                         (build-application
+                          no-source
+                          (build-primref no-source 'module-name)
+                          (list (build-application
+                                 no-source
+                                 (build-primref no-source 'current-module)
+                                 '())))))))))))
+  
   (define chi-when-list
     (lambda (e when-list w)
                                         ; when-list is syntax'd version of list of situations
@@ -1356,6 +1377,7 @@
 
   (define chi-macro
     (lambda (p e r w rib mod)
+      ;; p := (procedure . module-name)
       (define rebuild-macro-output
         (lambda (x m)
           (cond ((pair? x)
@@ -1377,14 +1399,9 @@
                                      (if rib
                                          (cons rib (cons 'shift s))
                                          (cons 'shift s)))
-                          (let ((pmod (procedure-module p)))
-                            (if pmod
-                                ;; hither the hygiene
-                                (cons 'hygiene (module-name pmod))
-                                ;; but it's possible for the proc to have
-                                ;; no mod, if it was made before modules
-                                ;; were booted
-                                '(hygiene guile))))))))
+                          ;; hither the hygiene
+                          (cons 'hygiene (cdr p)))))))
+                
                 ((vector? x)
                  (let* ((n (vector-length x)) (v (make-vector n)))
                    (do ((i 0 (fx+ i 1)))
@@ -1395,7 +1412,7 @@
                  (syntax-violation #f "encountered raw symbol in macro output"
                                    (source-wrap e w (wrap-subst w) mod) x))
                 (else x))))
-      (rebuild-macro-output (p (wrap e (anti-mark w) mod)) (new-mark))))
+      (rebuild-macro-output ((car p) (wrap e (anti-mark w) mod)) (new-mark))))
 
   (define chi-body
     ;; In processing the forms of the body, we create a new, empty wrap.
@@ -1556,7 +1573,7 @@
     (lambda (expanded mod)
       (let ((p (local-eval-hook expanded mod)))
         (if (procedure? p)
-            p
+            (cons p (module-name (current-module)))
             (syntax-violation #f "nonprocedure transformer" p)))))
 
   (define chi-void