- previously hidden when hashtable used a static method and a
  different class for end()

This uses a concept similar to what std::valarray and std::slice do.
A labelRange provides a convenient container for holding start/size
and lends itself to addressing 'sliced' views of lists.
For safety, the operations and constructors restricts the given input range
to a valid addressible region of the underlying list, while the labelRange
itself precludes negative sizes.

The SubList version is useful for patches or other things that have a
SubList as its parameter. Otherwise the UList [] operator will be the
more natural solution. The slices can be done with a labelRange, or
a {start,size} pair.

Examples,
     labelList list1 = identity(20);

     list1[labelRange(18,10)]  = -1;
     list1[{-20,25}] = -2;
     list1[{1000,5}] = -3;

     const labelList list2 = identity(20);
     list2[{5,10}] = -3;  // ERROR: cannot assign to const!

- improve interface consistency.

- optimize erasure using different HashTable based on its size.
  Eg, hashtable.erase(other);

  If 'other' is smaller than the hashtable, it is more efficient to
  use the keys from other to remove from the hashtable.

  Otherwise simply iterate over the hashtable and remove it if
  that key was found in other.

- some functionality similar to what the standary library <iterator>
  provides.

  * stdFoam::begin() and stdFoam::end() do type deduction,
    which means that many cases it is possible to manage these types
    of changes.

    For example, when managing a number of indices:
       Map<labelHashSet> lookup;

    1) Longhand:

        for
        (
            Map<labelHashSet>::const_iterator iter = lookup.begin();
            iter != lookup.end();
            ++iter
        )
        { .... }

    1b) The same, but wrapped via a macro:

        forAllConstIter(Map<labelHashSet>, lookup, iter)
        { .... }

    2) Using stdFoam begin/end templates directly

        for
        (
            auto iter = stdFoam::begin(lookup);
            iter != stdFoam::end(lookup);
            ++iter
        )
        { .... }

    2b) The same, but wrapped via a macro:

        forAllConstIters(lookup, iter)
        { .... }

Note that in many cases it is possible to simply use a range-based for.
Eg,
     labelList myList;

     for (auto val : myList)
     { ... }

     for (const auto& val : myList)
     { ... }

These however will not work with any of the OpenFOAM hash-tables,
since the standard C++ concept of an iterator would return a key,value
pair when deferencing the *iter.

The deduction methods also exhibits some slightly odd behaviour with
some PtrLists (needs some more investigation).

- make construct from UList explicit and provide corresponding
  assignment operator.

- add construct,insert,set,assignment from FixedList.
  This is convenient when dealing with things like edges or triFaces.

- propagate common erasure methods as HashSet::unset() method,
  for symmetry with HashSet::set()

- explicitly mention the value-initialized status for the operator().
  This means that the following code will properly use an initialized
  zero.

      HashTable<label> regionCount;

      if (...)
         regionCount("region1")++;

      ... and also this;

      if (regionCount("something") > 0)
      {
          ...
      }

  Note that the OpenFOAM HashTable uses operator[] to provide read and
  write access to *existing* entries and will provoke a FatalError if
  the entry does not exist.

  The operator() provides write access to *existing* entries or will
  create the new entry as required.
  The STL hashes use operator[] for this purpose.

- more hash-like methods.
  Eg, insert/erase via lists, clear(), empty(),...

- minVertex(), maxVertex() to return the smallest/largest label used

- improved documentation, more clarification about where/how negative
  point labels are treated.

BUG: wall/patch distance and inverseDistanceDiffusivity - updated dimensions and use meshWave as a default method for backwards compatibility.  Fixes #462

Dict lookup

See merge request !105

Use updated edge and labelPair containers

See merge request !106

Updated random numbers

See merge request !107

ENH: turbulentDFSEMInlet - ensure different procs initialise the random number generator with a different seed

- old Random class deprecated
- cachedRandom renamed Random

- simplifies organization, allows reuse.
  provide some other useful hash types.

- for loading single or multiple surface files from constant/triSurface
  (or other) directory.

- select based on word, wordRe, wordReList.

- performance improvement. Noticed while examining issue #458

- avoids some duplicate code.

- cannot use comparison of list sizes. Okay for UList, but not here.

STYLE:
- don't need two iterators for the '<' comparison, can just access
  internal storage directly

- The existing ':' anchor works for rvalue substitutions
  (Eg, ${:subdict.name}), but fails for lvalues, since it is
  a punctuation token and parse stops there.

- can be used to reduce copying

- makes more sense to bundle it with plane.

ENH: OBJstream output for treeBoundBox

- improves flexibility.

STYLE: make longestEdge a face method and deprecate the global function

- support edge-ordering on construction, and additional methods:
  - sort(), sorted(), unitVec(), collapse()

- null constructor initializes with -1, for consistency with face,
  triFace and since it is generally much more useful that way.

- add some methods that allow edges to used somewhat more like hashes.
  - count(), found(), insert(), erase()

  Here is possible way to use that:

      edge someEdge;  // initializes with '-1' for both entries

      if (someEdge.insert(pt1))
      {
         // added a new point label
      }

      ... later

      // unmark point on edge
      someEdge.erase(pt2);

--

STYLE:

- use UList<point> instead of pointField for edge methods for flexibility.

  The pointField include is retained, however, since many other routines
  may be relying on it being included via edge.H

- filter out degenerate edges
- remove unused points

STYLE: remove unused mergePoints() parameter

STYLE: doxygen for edgeMesh

- suppress error messages that appear with zsh.
  According to unset(1p), 'unset -f' unsets a function.
  If the function was not previously defined, this is a no-op.
  This is similar for zsh, but there it emits a warning if the
  function was not previously defined.

- avoid 'local' in functions sources from etc/bashrc.
  ksh does not support this.

- use 'command' shell builtin instead of 'type'.
  Seems to be more consistent between shell flavours.