fixes #1714

Using macros and preprocessor directives is the glsl way of doing this.
After this the .glsl files are now valid glsl. I think it's clearer to
have both variations explicitly written in glsl than having string
replacement.

This replaces a per-attribute `isDisabled` function with paint property
key. All data-driven attributes must now depend on only a single paint
property.

The `a_color` attribute used to depend on both the `circle-color` and
`circle-opacity` paint properties. This splits them up into two
attributes/uniforms, each of which only depends on one paint property.

I think it will be simpler to have all attributes be based on a single
style property. We will need to split up:
- a_color, which depends on -color and -opacity
- u_linewidth, which depends on line-width and line-width-gap

This prepares the shaders for the switch to data driven styling where
opacity and color need to be passed to the shader independent of
eachotehr.

remove the `additionalOpacity` parameter from `util.premultiply`

A function of the layer, globalProperties, featureProperties is simpler
than a string of code that gets joined into a function.

This separates the vertex push method for core attributes from the push
methods for data-driven attributes. This will let us:
- use a regular function for adding core attributes to buffers
- and either:
    - generate a separate method for data driven attributes
    - or optimize adding attributes without code generation

Data driven properties need to be evaluated once per feature, not once
per vertex. This means we can evaluate them outside the main vertex loop
and then add the same value for every vertex.

The hot loop for lines, fills and symbols will be:
for (var i = startIndex; i < endIndex; i++) {
    ...
}

If it's too slow in the current implementation we could add new
StructArray methods for setting a single value for a range of elements.
If we need to generate code it would be nice to contain that to
StructArray.

Now that paint attributes are added separately, we can switch to using
regular functions instead of code strings that are joined into a method.

This removes more code generation and it reduces the responsibility of
the `Bucket` parent class.

It's simpler to just add directly to the arrays.

- avoids the need to namespace attribute names with string concatenation
- this let's us use attribute.name as the shader attribute name
- this will let us use instanced rendering (#1898) with a shorter buffer
  when that extension is available.

since it no longer needs access to anything in Bucket

Set attribute pointers using info from the array type.