add wrapper for boost::mt19937 mersenne twister rng

The class mt_rng is a wrapper which provides a similar interface to
this boost rng class as we had to the linear congruential rng
implemented in simple_rng. This commit creates mt_rng.hpp and
mt_rng.cpp and adds them to SConscript and CMakeLists.

This commit also adds the boost::random depenency to SConstruct.
I mark the required version at 1.43.0, since from the boost
changelog, that's the last time that the random library was updated,
and inclued the change:

"Put the implementation of random_device in a compiled lib, and
added Windows support."

I imagine we might want to use that in a revision of this.

I also am forced to add an implementation of the "discard" rng
function, which seems be available on my machine but not in the
travis build environment.
switch over gamestatus and sync code to use mt_rng

In places where previously simple_rng was being used.
This may require fixup, as we are casting uint32's from
the rng to ints.
add boost rng to server for seeding mp games

TODO: It looks like this will still cast all uint32's from the rng
to ints before sending them to the clients, unclear if that causes
problems.
fixup mt_rng class to use boost::random_device
fixup mt_rng.hpp to include boost random device header correctly
fixup src/game.hpp to use boost random device header correctly
add preprocessor flags for no boost::random_device

If we don't have boost::random_device available on target
platform, then leaving the flag undefined will cause us
to use the ctime system time to get seeds.
server uses mt_rng class instead of raw boost rng

The server now holds an mt_rng for every game. Had to move mt_rng
to wesnoth_core in SConscript for this.
fixup comment
never cast random results from uint32_t to int

throughout the random wrappers and the code that uses them, make
sure to replace int's with uint32_t's.

it would be better to use boost distribution objections perhaps,
than modding rng results as we currently do.
fix cmake lists

add requirement for boost random 1.43.0
add mt_rng.cpp to libwesnoth-core, as I did for SCons already
store random_seed in cfg by lexical cast uint32_t <-> std::string

This commit changes the way seed info is handled by the server,
clients, and cfgs, to prevent silent conversion between int
types. In this version there is the drawback that rng construction,
and therefore game_state construction (!) can now throw a bad
lexical cast. This commit should be amended in the future to deal
with this appropriately.
fixup random_new.cpp (forgot to save before committing!)

I moved stdint.hpp include to the header but this change didnt
make it to the cpp.
fixup mt_rng constructor (with config & argument)

This is slightly less efficient but it prevents the possibility
of the rng constructor throwing a bad_lexical_cast in the
initializer list, so it seems worth it.
add seed_rng namespace and files

In order to separate the "seed source" objects from the actual
PRG objects, this adds a new file and name space "seed_rng" which
can be used by rng's which are constructed without a seed.

The implementation has preprocessor guards, and should be either
boost::random_device or just the system time if that is
unavailable.

Since it goes on server as well this file also needs to be in
wesnoth-core.
add std::string versions of seed, get_seed to mt_rng
fixup comment
use stringstream to get seeds from configs, not lexical cast

Also, get seed values for configs from the get_random_seed_str
function.

We don't otherwise mess with the types of synced_context etc.
The basic types of those objects, seed_generator etc. is the
same except that int -> uint32_t.

Fixes up commit cdefb9c98e8517c5c2b532970fdaf22d8c1b73de
refactor synced context to use std::string, not int, for seeds

This allows to mark the "seed" function of mt_rng which takes
a uint32_t as private, leaving only the std::string option
public.

With this change it should be completely unknown to the engine
that the mt rng internally uses uint32_t, only the wrapper class
should know this. There will still be some stringstream ops on
the server-side though, to map uint32_t rng results to hex strs.
add unit tests for rng

The tests validate only a small part of the functionality:

- boost::mt19937 with default seed gives a particular long int as
its 10,000'th query, specified by boost
- rand_rng::mt_rng class properly transforms seeds from uint32_t
to std::string in hex notation and back