Remove memory leaks resulting from registering Sacado parameters.

1. N.B. This commit accompanies one to Trilinos (packages/Sacado) and requires a
Trilinos pull and build.

2. valgrind reports a lot of memory leaks coming from the following code pattern
in Albany evaluators. Let Name be an evaluator. Name could be Dirichlet, for
example. The constructor is written like this:

PHAL_Name_Def.hpp:
template<typename EvalT,typename Traits>
NameBase<EvalT, Traits>::NameBase(Teuchos::ParameterList& p) {
  // ...
  new Sacado::ParameterRegistration<EvalT, SPL_Traits>(name, this, paramLib);
}

The 'new' line has no lvalue, so the pointer is lost, leaking the memory for
the new object. There can be multiple such registrations in a given
    NameBase : Sacado::ParameterAccessor.
The leaked memory is not substantial because each instance is very small; the
motivation for fixing this is that valgrind output for the leaks can be
thousands of lines, which makes it hard to check for other leaks.

3. To fix this, I added a new method to Sacado::ParameterAccessor:
    void registerSacadoParameter(const std::string& name,
                                 Teuchos::RCP<ParamLib>& paramLib);
and a new private variable:
    std::vector< Teuchos::RCP<
      ParameterRegistration<EvalType, EvalTypeTraits> > > pr_;
Now one calls
    this->registerSacadoParameter(name, paramLib);
The vector of RCPs pr_ takes care of the memory management.

4. This change touches >40 files and >100 instances, so I wrote a script to do
it. In case we want to use it in the future on other branches, here it is:

import os, re

def spr_get_files (base_dir):
    # Find all relevant files.
    cmd = "find " + base_dir + " -regex" \
          " '.*[.]\(cpp\|hpp\|h\|cc\|C\|H\|c\|h\)'" \
          " -exec grep -l 'new Sacado::ParameterRegistration<EvalT," \
          " SPL_Traits>' \{} \+"
    return os.popen(cmd).read().split('\n')

def spr_proc1file (fn):
    # Do a text replace in a file.
    with open(fn, 'r') as file:
        text = file.read()
    text = os.popen('cat ' + fn).read()
    # Pattern for old line.
    pat = '\n\s*(?P<whole>(?P<line>new Sacado::ParameterRegistration' \
          '<EvalT,\s*SPL_Traits>\s*\()' \
          '\s*(?P<arg1>.*)\s*,\s*this\s*,\s*(?P<arg3>.*)\))\s*'
    hits = re.findall(pat, text)
    # Print to stdout what is being substituted.
    print '-> ' + fn
    for h in hits:
        print '  -| ' + h[0]
        line = 'this->registerSacadoParameter(' + h[2] + ', ' + h[3] + ')'
        print '  +| ' + line
        text = re.sub(re.escape(h[0]), line, text)
    # Do the substitution.
    with open(fn, 'w') as file:
        file.write(text)

def spr_run ():
    # Run the whole thing.
    fns = spr_get_files('.')
    for fn in fns:
        if len(fn) > 0: spr_proc1file(fn)

On the Python command line, run

>>> import srct; srct.spr_run();

5. I ran ctest before and after these changes for this build:
    export ALB_64BIT_INT=ON
    export ALB_ENABLE_SCOREC=ON
    export ALB_ENABLE_LCM=ON
    export ALB_ENABLE_LAME=OFF
    export ALB_ENABLE_HYDRIDE=ON
    export ALB_ENABLE_QCAD=OFF
    export ALB_ENABLE_MOR=OFF
    export ALB_ENABLE_ASCR=OFF
    export ALB_ENABLE_AERAS=ON
    export ALB_ENABLE_FELIX=ON
    export ALB_ENABLE_AlbanyCI=OFF
    export ALB_DEBUG=OFF
    export ALB_ENABLE_CHECK_FPE=ON
    export ALB_ENABLE_SPECULATIVE=OFF
    export ALB_ENABLE_SG_MP=OFF
In both cases I get the following result:

96% tests passed, 10 tests failed out of 264

Total Test time (real) = 1121.75 sec

The following tests FAILED:
	 86 - CohesiveElement (Failed)
	 90 - SurfaceElementLocking (Failed)
	 92 - StabilizedTet4 (Failed)
	129 - Elasticity2DTraction (Failed)
	216 - SCOREC_ElastAdapt_SPR_Tpetra (Failed)
	219 - FELIX_FO_Dome_Restart (Failed)
	261 - SteadyHeat2D_perf (Not Run)
	262 - TLPoroElasticity3D_perf (Not Run)
	263 - Necking3D_MMODEL_perf (Not Run)
	264 - FELIX_FO_MMS_perf (Not Run)