Convergence tolerance for projection from 1e-15 (for testing) to 1e-12.

Might make it an option later. Also added a header doc.
Fix when response functions are called.

BRIEF. (b3) Evaluate response functions only when NOX converges or LOCA
completes a continuation step. Previously, (b1) response functions were
evaluated at every Newton iteration in the Tpetra-Thyra code path.

DISCUSSION. LOCA:: and NOX::Thyra::Group keep a class field out_arg_. Albany::
ModelEvaluatorT::createOutArgsImpl() previously called set_g on the OutArg
reference. I suspect this call was motivated by the fact that otherwise (b2)
response evaluators with EvalT = PHAL::AlbanyTraits::Residual called by
Albany::FieldManagerScalarResponseFunction are never called.

However, because out_arg_ is a class variable, calling set_g on it once means at
least one EvalT form of the response evaluators is called at every call to
computeF(). At iterations prior to convergence, it is the EvalT =
PHAL::AlbanyTraits::Residual form; at convergence it is the Tangent and Jacobian
forms. Additionally, response functions have evaluateResponseT called at every
nonconvergence iteration and evaluateTangentT and evaluateDerivativeT at
convergence.

(d1) Response functions are designed to avoid redundant computations. Hence
evaluateResponseT is not called if the TangentT or DerivativeT methods are
called. I think the idea is that the latter two methods compute the data needed
in evaluateResponseT in the course of computing tangent and gradient data, and
so can return these data. This design choice is made concrete by the presence of
Tpetra_Vector* gT as an output in all three of the methods evaluateResponseT,
evaluateTangentT, and evaluateDerivativeT. Furthermore,
Albany::ModelEvaluatorT:: evalModelImpl enforces this assumption with its
g_computed boolean.

As far as I can tell, (d2) there is no hard evaluator design assumption that the
Residual evaluator's data are also computed in the Tangent and Jacobian
evaluators. I'm thinking that the nature of PHX::MDField<T> relative to EvalT is
such that it is not natural to expect the Tangent form of the evaluator also to
do the Residual form's work.

Albany::FieldManagerScalarResponseFunction is a wrapper around response
computations that are built using evaluators. It is implemented according to
design assumption (d1) but calls evaluators implemented according to design
assumption (d2). I suspect these conflicting design assumptions are essentially
why so far we have had behaviors (b1) and (b2), neither of which is exactly what
we want.

SOLUTION. Consequently, to get behavior (b3), I have modified Albany::
FieldManagerScalarResponseFunction to be able to call the Residual evaluators in
all three of its methods rather than just the first, though ultimately it makes
those calls from only one. In addition I slightly modified Albany::
ModelEvaluatorT::evalModelImpl to refine the logic. Instead of using the
g_computed boolean, I use the RCP gT_out to control whether the Residual
response evaluator is called. As a result, only one of three code paths for the
Residual response evaluator is executed.

These two changes I believe make Albany consistent with the intent of Piro::
SteadyStateSolver<Scalar>::evalConvergedModel. However, that method is called
only after the final LOCA step. I need to change the behavior on the Piro side
so that the response functions are called after every LOCA step.