Introduce new polar integration types

Previously the RadialIntegrationType assumed that the hard factors it
was being used for had no angular dependence, and thus when given a
radial coordinate r it would always set rx=r,ry=0. This commit
introduces an integration type that does allow for angular dependence,
and properly sets rx=r cos(theta),ry=r sin(theta). It also introduces an
analogous integration type for momentum, and extends that type to one
that provides an upper cutoff on q_perp. The cutoff is calculated to
satisfy x_a <= 1 in the exact kinematics.
Get IntegrationType to calculate the jacobian

Fully specifying an integral requires specifying the bounds, the
transformations from the variables of integration to the kinematic
variables, and the jacobian. With this commit, all of this is handled
in the IntegrationType, rather than the jacobian being calculated
in integrator.cpp, so the jacobian can change with the integration
type as it should.

Conflicts:
	src/integrationtype.h
Mention angular limits in docs for RadialIntegrationType

This commit changes the documentation for RadialIntegrationType to
mention that every other variable of integration is an angle with
limits 0 and 2pi.
Move 2*pi*r from radial hard factors to radial jacobian

The radial (position) hard factors in hardfactors_radial.cpp
previously included a factor of 2*pi*r which came from the jacobian
for converting from polar to Cartesian coordinates. This commit
moves that factor from the hard factors to the jaconian in
the corresponding integration type.
Always include subtractions from plus prescription

A previous commit removed the calculation of the extra terms introduced
by the plus prescription when using the exact kinematics because the
exact kinematic integration region excludes xi=1. This commit restores
those terms.
Convert fill_min and fill_max to use Context

fill_min and fill_max shouldn't need any information from the
IntegrationContext except for the Context reference, so this commit
changes their signatures so that they directly accept the Context.
This allows fill_min and fill_max to be called even when an
IntegrationContext is not available.

Conflicts:
	src/integrationtype.h
Move the conversion of (z,y) to (z,xi) into IntegrationType instances

This commit moves the code that converts from the integration variables
(z,y) to the kinematic variables (z,xi) from
IntegrationContext::update_kinematics() to IntegrationType::update().
This way the IntegrationContext object only "knows" about the kinematic
variables. Everything to do with converting to and from Monte Carlo
integration variables with constant limits is now encapsulated in the
methods of IntegrationType.
Create separate functions to calculate kinematic limits

This commit breaks out the computation of the kinematic limits on z and
y into separate functions in integrationtype.cpp. These limits can be
easily adjusted by altering the code in just these few functions. It
also reduces the number of places in which the exact_kinematics flag
is referenced.
Enable preprocessor flag for switching limit scheme

This allows the program to be compiled to use either Bowen's scheme
for integral limits (where the max of the xi integral is set at
1 - xahat) or mine (where the max is set to 1), depending on the
definition of the directive EXACT_LIMIT_SCHEME