[mem.res.pool.overview] add proper definitions of terms

Update cross-reference in [mem.res.pool.options] to refer to
[mem.res.pool.overview].

Fixes #1258

Author: jwakely

source/utilities.tex

@@ -11806,30 +11806,54 @@
 are general-purpose memory resources having the following qualities:
 \begin{itemize}
 \item
-Each resource frees its allocated memory on destruction,
-even if \tcode{deallocate} has not been called for some of the allocated blocks.
+A pool resource has an \defn{upstream memory resource},
+supplied on construction, which is used to allocate memory that
+the pool resource subdivides to satisfy calls to its own
+\tcode{do_allocate} member.
+
+\item
+A \defn{chunk} is a region of storage allocated
+from the upstream memory resource. A pool resource divides
+each chunk into one or more blocks of the same block size.
+Different chunks can have different block sizes, and different
+numbers of blocks.
+
+\item
+A \defn{pool} is a collection of chunks that all have the same
+block size. Each pool resource contains a collection of pools
+with different block sizes.
+
+\item
+On destruction, a pool resource frees all the memory it obtained from
+its upstream memory resource by calling the upstream resource's
+\tcode{deallocate} function.
+\begin{note}
+This frees all memory returned by the pool resource's \tcode{do_allocate}
+function, even if \tcode{do_deallocate} has not been called for some
+of the allocated blocks.
+\end{note}
+
 \item
-A pool resource consists of a collection of \defn{pools},
-serving requests for different block sizes.
-Each individual pool manages a collection of \defn{chunks}
-that are in turn divided into blocks of uniform size,
-returned via calls to \tcode{do_allocate}.
 Each call to \tcode{do_allocate(size, alignment)} is dispatched
-to the pool serving the smallest blocks accommodating at least \tcode{size} bytes.
+to the pool serving the smallest blocks accommodating at \tcode{size} bytes
+and are aligned to a multiple of \tcode{alignment}.
+
 \item
 When a particular pool is exhausted,
 allocating a block from that pool results in the allocation
-of an additional chunk of memory from the \defn{upstream allocator}
-(supplied at construction), thus replenishing the pool.
+of an additional chunk from the upstream memory resource,
+thus replenishing the pool.
 With each successive replenishment,
 the chunk size obtained increases geometrically.
 \begin{note}
 By allocating memory in chunks,
 the pooling strategy increases the chance that consecutive allocations
 will be close together in memory.\end{note}
+
 \item
-Allocation requests that exceed the largest block size of any pool
-are fulfilled directly from the upstream allocator.
+Allocation requests that exceed the largest block size and/or alignment
+of any pool are fulfilled directly from the upstream allocator.
+
 \item
 A \tcode{pool_options} struct may be passed to the pool resource constructors
 to tune the largest block size and the maximum chunk size.
@@ -11925,7 +11949,7 @@
 \begin{itemdescr}
 \pnum
 The maximum number of blocks that will be allocated at once
-from the upstream memory resource\iref{mem.res.monotonic.buffer}
+from the upstream memory resource\iref{mem.res.pool.overview}
 to replenish a pool.
 If the value of \tcode{max_blocks_per_chunk} is zero or
 is greater than an \impldef{largest supported value to configure the maximum number of blocks to replenish a pool}