Deprecate implicit conversion of Resource<T, U> to U&.

We are allowing implicit conversions only if they are harmless and this
is *not* harmless, as it might fire an assertion. The user should use
operator*() or operator->() instead, which will make these conversions
stand out more in the code. Also reduced code duplication.
Explicitly passing shader to Mesh*::draw().

Previously the API didn't encourage the user to set up and activate
shader before drawing the meshes, leading to unintuitive behavior:

    // Can I just call draw() or do I have to fully understand the
    // meaning of the universe before?
    mesh.draw();

Now the draw() needs the shader passed explicitly as parameter, which
should hint that the shader must be set up somehow:

    // Right, so this needs just a shader and that's all. Expecting this
    // I fortunately *did* configure all the uniforms before this call.
    mesh.draw(shader);

It is also possible to pass the shader as rvalue, in case the drawing is
just a one-off thing and is already fully configured.

    mesh.draw(MyShader{});

As usual, the original API is kept, is marked as deprecated and will be
removed in some future release.
DebugTools: fix obsolete reference in documentation.
doc: hint that these function actually take some parameters.

This looked like valid code, which is not.
Use functions to bind textures to shader rather than *Texture::bind().

Why did I do this:

 * It is more clean, shorter and nice looking with method chaining,
   i.e. instead of:

    shader.setColor(...)
          .setOtherParam(5);
    texture1.bind(MyShader::Texture1Layer);
    texture2.bind(MyShader::Texture2Layer);

   We now have this:

    shader.setColor(...)
          .setOtherParam(5)
          .setTexture1(texture1)
          .setTexture2(texture2);

 * It is now also clear which texture type is expected, the layer
   constant did not say anything about type.
 * Also it is possible to use new features (multi bind, bindless
   textures etc.) while preserving the same public API.

The only potential disadvantage is that the textures don't stay bound
like uniform values do, but this become a non-issue with bindless
textures. As usual, the old way is now deprecated and will be removed in
some future release.
Deprecate AbstractTexture::maxLayers() altogether.

*Texture::bind() is now meant to be used only internally from shaders,
thus this function is not needed at all, as we should query directly the
particular shader type for the limits.

The name also somehow clashes with layered textures, which should be
avoided.