Remove all definitions of println(...) from Print.cpp except println(void),
and replace them with inline methods in Print.h.
This simplifies the code in Print.cpp improving maintainability.

Remove print(char | char[] | Printable | unsigned char | int | unsigned int)
from Print.cpp and replace them with inline versions in Print.h.

Add explicit print() support for signed char, unsigned/signed short, and float.
Also, add `signed` keyword explicitly to int and long (even if unnecessary).

Notice that `char` and `signed char` are considered different types,
even if their ranges are the same (ditto for `unsigned char` in SAM).
Both AVR and SAM seem to define [u]int8_t explicitly as [un]signed char
and not as char, so printing them will print them as numbers as expected.
(This does not apply to `int` and `signed int`; those are the same type.)

Add GCC __attribute__ ((__always_inline__)) to inlined methods in Print.h.
This seems necessary since not doing so increases the executable size
(probably because that would create several function definitions),
even with LTO optimizations.
This change combined with the inlining of print/printf methods seems to reduce
the executable size for most applications by a fair amount.
(Note that the `inline` keyword does not imply actual inlining.)

Allows combining multiple arguments into a single call to Print::print[ln], like Serial.print("Answer=", 66, HEX).
This feature requires C++11 or newer to work, but if it is not available the old calls can still be used (the change has been wrapped in `#if __cplusplus >= 201103L ... #endif`).
This change is backwards compatible: print(42, 16) prints "2A" as always, not "4216" (the latter can still be achieved with print(42, "", 16) ).  This also works with multiple arguments: any numeric argument followed by an int will be treated as a (number, format) pair.
The variadic function calls are inlined using an __attribute__ ((__always_inline__)), so they're equivalent to writing multiple sequential calls to print with one argument.

This allows passing formatters to print. E.g. instead of print(10, HEX),
you can pass any object that has a suitable printTo(Print*, ValueT)
method.

This is a WIP on top of the variadic print PR and it makes some changes
that should probably go into there.

As an example of usage:

	struct EvenOddFormatter {
	  int printTo(Print *p, int x) {
	    return p->print(x % 2 ? "odd" : "even");
	  }
	};

	Serial.println(1, EvenOddFormatter());