simplify elisp symbol accessors

* module/language/elisp/boot.el (fset, symbol-value, symbol-function)
  (set, makunbound, fmakunbound, boundp, fboundp): Use procedures in
  `(language elisp runtime)'.
  (symbolp): New function.

* module/language/elisp/compile-tree-il.scm (set-variable!): Use
  `set-symbol-function!'.

* module/language/elisp/runtime.scm (reference-variable, set-variable!):
  Remove.
  (symbol-fluid, set-symbol-fluid!): New procedure.
  (symbol-value, set-symbol-value!, symbol-function)
  (set-symbol-function!, symbol-bound?, symbol-fbound?, makunbound!)
  (fmakunbound!): Moved from `(language elisp subrs)' and updated to
  avoid using `reference-variable' and `set-variable!'.

* module/language/elisp/runtime/subrs.scm (symbol-value)
  (symbol-function, set, fset, makunbound, fmakunbound, boundp)
  (fboundp): Move to `(language elisp runtime)'.
  (apply): Use `symbol-function'.

module/language/elisp/runtime.scm

@@ -25,8 +25,16 @@
             function-slot-module
             elisp-bool
             ensure-fluid!
-            reference-variable
-            set-variable!
+            symbol-fluid
+            set-symbol-fluid!
+            symbol-value
+            set-symbol-value!
+            symbol-function
+            set-symbol-function!
+            symbol-bound?
+            symbol-fbound?
+            makunbound!
+            fmakunbound!
             runtime-error
             macro-error)
   #:export-syntax (defspecial prim))
@@ -77,31 +85,73 @@
           (module-define! resolved sym fluid)
           (module-export! resolved `(,sym))))))
 
-(define (reference-variable module sym)
-  (let ((resolved (resolve-module module)))
-   (cond
-    ((equal? module function-slot-module)
-     (module-ref resolved sym))
-    (else
-     (ensure-fluid! module sym)
-     (fluid-ref (module-ref resolved sym))))))
+(define (symbol-fluid symbol)
+  (let ((module (resolve-module value-slot-module)))
+    (ensure-fluid! value-slot-module symbol) ;++ implicit special proclamation
+    (module-ref module symbol)))
 
-(define (set-variable! module sym value)
-  (let ((intf (resolve-interface module))
-        (resolved (resolve-module module)))
-    (cond
-     ((equal? module function-slot-module)
-      (cond
-       ((module-defined? intf sym)
-        (module-set! resolved sym value))
-      (else
-       (module-define! resolved sym value)
-       (module-export! resolved `(,sym)))))
-    (else
-     (ensure-fluid! module sym)
-     (fluid-set! (module-ref resolved sym) value))))
+(define (set-symbol-fluid! symbol fluid)
+  (let ((module (resolve-module value-slot-module)))
+    (module-define! module symbol fluid)
+    (module-export! module (list symbol)))
+  fluid)
+
+(define (symbol-value symbol)
+  (fluid-ref (symbol-fluid symbol)))
+
+(define (set-symbol-value! symbol value)
+  (fluid-set! (symbol-fluid symbol) value)
   value)
 
+(define (symbol-function symbol)
+  (let ((module (resolve-module function-slot-module)))
+    (module-ref module symbol)))
+
+(define (set-symbol-function! symbol value)
+  (let ((module (resolve-module function-slot-module)))
+   (module-define! module symbol value)
+   (module-export! module (list symbol)))
+  value)
+
+(define (symbol-bound? symbol)
+  (and
+   (module-bound? (resolve-interface value-slot-module) symbol)
+   (let ((var (module-variable (resolve-module value-slot-module)
+                               symbol)))
+     (and (variable-bound? var)
+          (if (fluid? (variable-ref var))
+              (fluid-bound? (variable-ref var))
+              #t)))))
+
+(define (symbol-fbound? symbol)
+  (and
+   (module-bound? (resolve-interface function-slot-module) symbol)
+   (let* ((var (module-variable (resolve-module function-slot-module)
+                                symbol)))
+     (and (variable-bound? var)
+          (if (fluid? (variable-ref var))
+              (fluid-bound? (variable-ref var))
+              #t)))))
+
+(define (makunbound! symbol)
+  (if (module-bound? (resolve-interface value-slot-module) symbol)
+      (let ((var (module-variable (resolve-module value-slot-module)
+                                  symbol)))
+        (if (and (variable-bound? var) (fluid? (variable-ref var)))
+            (fluid-unset! (variable-ref var))
+            (variable-unset! var))))
+    symbol)
+
+(define (fmakunbound! symbol)
+  (if (module-bound? (resolve-interface function-slot-module) symbol)
+      (let ((var (module-variable
+                  (resolve-module function-slot-module)
+                  symbol)))
+        (if (and (variable-bound? var) (fluid? (variable-ref var)))
+            (fluid-unset! (variable-ref var))
+            (variable-unset! var))))
+  symbol)
+
 ;;; Define a predefined macro for use in the function-slot module.
 
 (define (make-id template-id . data)