Move detectEdge to the @fun level.
Enabling edge detection for blowing up functions.
Restoring the modification for the function handle in the presence of singularities.
Prevent edge detection at infinity.
Use filtered integrand in ubndnfun.sum().

This ought to help us with some of the accuracy problems we've been
having with unbndun.sum().  This effectively implements the filtering
scheme for doing these integrals which was used in Chebfun v4.  The idea
is that values of the function being integrated which are really small
are set _exactly_ to zero to prevent the magnifiction of rounding error
due to the blowup of the nonlinear map at the endpoints of [-1, 1].

The one oddity is that we use an exact-length construction for the
integrand.  This is a hack:  it only works for chebtech, and even then,
there's no real reason that it should.  We would like to do an adaptive
construction here, but that has proved difficult, as the fact that the
nonlinear map rescales very wide intervals near +/-Inf to very narrow
ones near +/-1 means that the filtered integrand exhibits sharp
transitions on Chebyshev grids of any reasonable size.

This commit is essentially a cleaner version of work started by KX
elsewhere, and many of the changes in this commit come from him.
Bypass singfun when constructing unbndfun integrands.

With the changes from the previous commit, unbndfun.sum() would
construct the integrand using g.onefun.make().  This means that if g is
a singfun, the singfun constructor gets called, which is not what we
want.  Since the integrand does not blow up, we don't need to do
singularity detection here; in fact, doing this causes one test to fail
due to the inaccuracies in the singularity detector.

This commit solves this by adding a 'techConstructor' option to the
get() methods of the interior layers (but not to chebfun).  A get(f,
'techConstructor') call is passed all the way down to the bottom, until
it hits a tech, which returns a handle to its own constructor.  This is
useful, non-encapsulation-breaking way to set pref.tech.  In our case,
since a tech is exactly what we want to construct, we don't bother with
preferences here and just invoke the constructor we get back directly.
Add classicfun.normest().
An attempt at more robust filtering of spurious roots in unbndfun.roots().

Previously, we set a threshold at around 10^15, and if the (magnitude of
the) location of a root was above this threshold, it was deemed likely
to be spurious, arising only due to the fact that the function being
represented decays rapidly at infinity.  Unfortunately, this criterion
isn't strict enough to handle this most of the time.  For instance, we
have following example from test 28 in tests/chebfun/test_norm():

  >> f = chebfun(@(x) (1 - exp(-x))./(x.^2), [1 Inf]);
  >> roots(f)
  ans =
     1.0e+07 *
     9.821248494834144
                   Inf

This commit tries to remedy this by checking to see if the function is
"essentially zero" on the interval between a root and +/- Inf and, if
so, decides that the root is spurious.  It does the check by restricting
f to the relevant interval and calling normest() to get a quick measure
of its size.  This is obviously expensive, but it seems to work, at
least for the preceding example:

  >> f = chebfun(@(x) (1 - exp(-x))./(x.^2), [1 Inf]);
  >> roots(f)
  ans =
     Inf

This does not yet work for array-valued unbndfuns.  I will implement
this if people decide that this is a good idea.
Move code to filter endpoint roots down into chebtech.

Technically, I suppose this belongs there, as all the problems which apply to
unbndfun apply equally to a chebtech formed from a function composed with a
suitable map.  This is also probably faster, as we can just do point evaluation
instead of having to call restrict().

We reinstate the old "far-field" filtering method in unbndfun, as it seems to
catch some cases that these changes miss.

Remarkably, all the tests pass, at least for me, but this still needs more
vetting before we can call it truly stable.
Move code block to subfunction and tidy up.
Reinstate test for 1-norm on unbounded domains.

With the root-filtering changes just made, this test now passes for me,
though it would be good if we could run it on a few other machines to be
sure.
Apply fix from KX for unbndfun.innerProduct().

This closes #578 (though I don't fully understand why).  Also adds KX's
test for this issue.
Add test from KX for issue related to unbndfun.sum().

The changes in the preceding commits close #496, and this commit adds a
check for that.  Also, disable an erroneously-issued warning about slow
decay.
Minor.
Merge branch 'development' into fix-detectEdge

Conflicts:
	tests/chebop/test_nonlinearSystemDampingBreakpoints.m
Properly passing the exponents in test for bndfun constructor.
Tweaking a test in unbndfun/test_sum.m
Normalizing EIGfuns returned so that they're always positive
at an arbitrary point just right to the midpoint of the domain.
Cosmetic changes.
fine tuning tolerances for @deltafun/restrict