Memoization mods to fix performance monitoring and perhaps increase efficiency slightly.

Also, tweaked :doc git-quick-start.  (In particular, paragraph
end/start markers seemed to be missing but I liked how the first two
"paragraphs" were shown as a single paragraph, so I eliminated the
blank line between them.)

When a function is memoized with lower-overhead or :stats nil, the
performance monitoring statistics (for (memsum)) no longer consider
that function.  The statistics previously were, I think, a bit messed
up.  If you evaluate the following sequence of forms before and after
this commit, you'll see what I mean.

(defn f1 (x) x)
(defn f2 (x) (f1 x))
(defn f3 (x) (f2 x))
(memoize 'f1)
(memoize 'f2 :stats nil)
(memoize 'f3)
(progn$ (f3 3) (f3 3) (f3 3) (f3 3) (f3 10))
(memsum)

I also tweaked code generation for memoized functions to improve
efficiency, though it's not clear that it made much of a difference.
Here are some test results.

; Original version:

; (EV-REC *RETURN-LAST-ARG3* ...) took
; 96.65 seconds realtime, 96.49 seconds runtime
; (4,167,707,904 bytes allocated).

; New version:

; 96.39 seconds realtime, 96.16 seconds runtime
; (4,167,707,392 bytes allocated).

; Original version, starting with (lower-overhead):

; 96.19 seconds realtime, 96.02 seconds runtime
; (4,167,707,904 bytes allocated).

; New version, starting with (lower-overhead):

; 95.68 seconds realtime, 95.46 seconds runtime
; (4,167,707,904 bytes allocated).

Technical changes:

- In memoized function code generation, a call of
  unwind-protect-disable-interrupts-during-cleanup has been replaced
  by a prog1, multiple-value-prog1, or progn, which might slightly
  increase efficiency with the trade-off that performance monitoring
  statistics could be off a bit when there is an interrupt.

- To support the change above, *caller* and the start-ticks variables
  are ordinary specials, no longer introduced with defg.

- In memoized function code generation, FLET is no longer used, which
  might improve efficiency slightly but could cause code size to
  double or, if a :condition is supplied, triple.

- Memoized function code generation has an optimization when
  :condition is t or 't, which is now significant since it omits
  laying down one call of the body now that FLET is no longer used.

- Memoized function code is a bit more efficient when :aokp is true.
  More important probably, the code for memoize-fn-inner-body is a bit
  more readable.

- A missing mfixnum declaration was added for the start-ticks variable
  in memoize-fn-outer-body.
VL updates for SystemVerilog packages and better implicit wire handling

 - Added basic representation and parsing for packages.
 - Extended module/interface parsing to reject invalid elements such as module
   instances inside of interfaces, modports inside of modules, etc.
 - Fixed interface parsing to not try to add implicit wires since that
   doesn't make sense.
 - Tweaked starting location for user-defined primitives
 - Reworked make-implicit-wires and portdecl-sign to be ordinary transforms
   that happen outside of loading, toward being able to support package
   imports.
 - Minor reorganization, collected some "annotate" transforms into a new
   transforms/annotate subdirectory.
 - Other minor documentation updates

FTY: add some stronger defalist count theorems (with Sol)
untested support for replication assignment patterns
make-implicit-wires fixes
Kaufmann patches std::define such that it now provides a :redundant output when a define is redundnat.  Kaufmann writes:

Upon success we now see the name being returned, where before it
looked like nothing was returned, though in fact (value :invisible)
was returned -- as you can see if you first evaluate
(set-ld-error-triples nil state) before the define form.  But anyhow,
that's a minor point, easily changed.  The more interesting mod is
that if the world wasn't modified, then (value :redundant) is
returned.

One thing you or Jared might notice is that in my implementation,
I check equality of two worlds with EQUAL.  I tried EQ but got a
guard violation that I think is unavoidable.  But I think EQUAL will
be fast -- either the recursive equality test will fail very quickly, or
the worlds will actually be EQ and hence EQUAL will return t very
quickly.  Initially I compared their lengths, but I think computing
lengths might often be more expensive and almost never cheaper.

Fixes #220
add support for imports in scopestack
extend make-implicit-wires to handle imports
Merge with sol's scopestack stuff
Adding a reference to the xdoc topic from 'books-certification' and 'build-the-manual'.  Also changed the canonical command used to build the manual.  I considered listing both commands but decided less to read was better.

Fixes #289.
Make build-single.sh use -j2 instead of -j3.
Improved function proclaiming for GCL.

Quoting :doc note-7-0:

  (Should essentially affect GCL only) Significant re-work has been
  done for function proclaiming, which is still only done when the
  host Lisp is GCL. In particular, the build process now has extra
  steps even for other Lisps though for them, the extra steps are
  trivial (technical details may be found in the comment labeled
  ``Essay on Proclaiming'' in source file acl2-fns.lisp). We also
  have improved the calculation of return types. Thanks to Camm
  Maguire for helpful discussions, in particular for pointing out
  that the re-proclaiming that had been done previously could lead to
  buggy behavior.
vl: change imports support in scopestack to better track the origin of names
Merge jaredxb into assignpats
add imports to modules and interfaces
temporary shadowcheck stuff
Merge remote-tracking branch 'remotes/solnew/assignpats'
first version of shadow check
Fixed an error that occurred when proclaiming in GCL.  Miscellaneous other, very small fixes.

Fixed an error that occurred when proclaiming in GCL, and tweaked some
comments.

Fixed slight bug in oracle-apply and oracle-apply-raw (only occurs for
non-live state in raw Lisp), found during automatic proclaiming.

Avoid warning during ACL2(h) builds, about ignoring memoization
requests in raw Lisp.
Modified GCL function proclaiming to use GCL's own mechanism.

Thanks to Camm Maguire for help with this.

The ACL2-based mechanism is available, easily restored by setting
variable *do-proclaims* to t.  But GCL's is faster, based on these
experimental results for ACL2(h) regressions (using a GCL 2.6.12pre1
ANSI build supplied by Camm Maguire):

- With ACL2 proclaiming:
39365.260u 1577.374s 1:34:29.53 722.1%	0+0k 888280+5404376io 624pf+0w

- With GCL's own proclaiming:
38519.259u 1611.440s 1:32:18.07 724.6%	0+0k 882072+5324672io 619pf+0w

I like the idea of relying on GCL's proclaiming.  My understanding
from Camm Maguire is that future GCL versions might do a yet more
complete job.

NOTE: ACL2's proclaiming is still used (in GCL) for user-defined
functions, i.e., after the build.  It's only during the build
("boot-strap") that GCL's mechanism is used.  Perhaps some day we'll
revisit that.

It might be of some value to look carefully at what is generated in
file acl2-proclaims.lisp using ACL2's proclaiming (*do-proclaims* = t)
vs. GCL's proclaimng (*do-proclaims* = :gcl, as is now the case).  It
might also be of some value to re-visit using ACL2's proclaiming in
other Lisps -- past experiences in CCL and Allegro CL were not
promising, but ACL2's proclaiming has very recently been improved.

Anyhow, here is the revised version of the existing paragraph from
:doc note-7-0 on proclaiming:

  (Should essentially affect GCL only) Significant re-work has been
  done for function proclaiming, which is still only done when the
  host Lisp is GCL. In particular, the build process now has extra
  steps even for other Lisps though for them, the extra steps are
  trivial (technical details may be found in the comment labeled
  ``Essay on Proclaiming'' in source file acl2-fns.lisp). We now use
  GCL's automatic proclaiming mechanism to calculate function types
  during the build (boot-strap), as we have seen it perform better
  than our own. Thanks to Camm Maguire for helpful discussions, in
  particular for explaining that mechanism and for pointing out that
  the re-proclaiming that had been done previously during the build
  could lead to buggy behavior.
Make build-single.sh use -j1 instead of -j2.