Fix round-robin for networks that support it

Some IRC networks perform round-robin by supplying a list of IP addresses
in their DNS records. However, Qt a) always uses the first address of that
list, and b) caches DNS records for a minute. This results that users who
connect at a roughly similar time (like at core startup) will all pick the
same IP for a given round-robin network address.

We now force Qt (simply by calling QHostInfo::fromName()) to perform a fresh
lookup every time it connects to an IRC network, which solves this problem.
However, this will not help you if your OS uses a system DNS cache that does
not reshuffle the list of IPs for repeated lookups.
Bump inxi version to 2.1.1

Hasn't been bumped in rather a while.
Update ChangeLog
Yet another inxi version bump

This fixes the term-related warnings the last version had.
Bump version.inc for release
Start of 0.11 cycle
Bump CMake version requirement to 2.8.9

Time to modernize our build system, making use of all the fancy features
that have crept into CMake in the past few years. While 2.8.9 is by far not
the latest version, it is rather widely deployed in distros at this time and
thus seems to be a reasonable choice as a minimum requirement.
Remove obsolete CMake scripts

We no longer need to bundle our own versions of FindOpenSSL and
FindPkgConfig, as recent CMake versions ship them.
Update currently bundled CMake scripts

We still need to bundle some CMake scripts that are not part of a
standard CMake installation, and may not be present in particular
on non-UNIXy platforms (as e.g. Windows does not have the concept
of a system-wide CMake script location).

Let's use current versions of those.
Update README and COPYING-CMAKE-SCRIPTS

Just to make clear how to handle the files we bundle.
genversion-B-GONE

Back in the day, we wanted to have information about the git hash a
particular Quassel binary was built from in the About dialog, to allow
for diagnostic purposes. However, we didn't manage to retrieve that
kind of information using CMake alone (we're talking CMake 2.4 here, too);
so we came up with the hack to compile a small binary that would be run
at build time and called the git executable in order to write version
information into a file.

This is not particularly nice, as running random binaries at build time is
frowned upon and can cause problems in some setups, and of course we have
the overhead of building it first.

Meanwhile, we found a nice set of CMake macros created by Ryan Pavlik that
would retrieve that information purely running Git commands, making genversion
obsolete. Together with the configure_file feature of CMake, this allows us
to do this more elegantly.

So gone is genversion, and also the good old trusted version.inc file...
Don't look recursively for a .git dir

The original GetGitRevisionDescription.cmake script would look for
a .git dir recursively in the parent directories of its invocation;
while a nice feature, it may pick up an unrelated repository if there's
none in the Quassel directory. Because we know exactly where to find
our own .git if it's there at all, we can remove the recursion and
prevent this issue.
Disable Github's Travis CI for now

Since the Github build servers have only CMake 2.8.7, we can't build there
at the moment. We'll re-enable this once they upgrade their servers, or
alternatively if we decide that we can relax the CMake requirement a bit.
Install current cmake in Travis CI environment
Move all CMake scripts one level up

Having them in cmake/modules/ just adds a pointless extra directory,
so let's move them directly into cmake/.
Move compile settings into a separate CMake module

That stuff just clutters the main CMakeLists.txt and is better off
in a separate file.
Enable automoc

Finally we can make use of this very convenient CMake feature and have
the moc stuff handled automagically. No need to list the headers anymore
for feeding them into the long-deprecated qt4_wrap_cpp macro.

Also, this should compile a bit faster and lead to slightly better optimized
code, because automoc will combine all the generated moc stuff for a target
into a single translation unit.

Note that we could get rid of various empty .cpp files (where all the code
is in the header) by just adding the header to the sources list; that way,
automoc will pick them up. There is no need to have a dummy .cpp file for
that.
Simplify handling of (dual-)Qt in the build system

We've used a somewhat complex way to link the various targets to the
required Qt libraries (and use the correct defines and CFLAGS...), because
when that stuff was written, there were no target properties in CMake, and
thus it was not easily possible to build targets within the same scope with
different settings. Therefore, we couldn't use the QT_USE_FILE and had to
write our own library handling.

These days, target properties exist, and Qt5 came up with a nice way to attach
the needed properties based on the Qt modules in use: qt5_use_modules()
This was later backported to Qt4, too, replacing the old way of having to
include QT_USE_FILE which would then set global variables.

We now make use of this; because qt4_use_modules() only showed up in
CMake 2.8.10, we've copied that function. It will be used only if it's
not present in CMake proper.

As a bonus, I've also wrapped all the qt-related macros into functions
that do the check for the Qt version we want to build against, and select
the proper macro to call, thus removing lots of WITH_QT5 conditionals
from the rest of the build system. Note that Qt5 support is still incomplete,
anyway.
Don't actually build miniz if we have zlib

We don't use miniz if we have zlib; but it was still being built, because
we never actually set HAVE_ZLIB as a build system variable.

Use ZLIB_FOUND instead.
Only create the regular expression for content/sender matches once.

Fixes #1227.