A bold move: modularize everything

This patch is a fairly substantial patch as it both touches many files, moves some around, and in part changes how the build system works.

This patch introduces a new way to select what parts of Contiki that are to be compiled. In the past, we've had three ways to selectively compile Contiki: the `APPS` make variable, the `TARGET` make variable, and various forms of Makefile magic (like `UIP_CONF_IPV6=1` and friends). Of those, the `APPS` variable has worked really well and we've begun using it at Thingsquare for other things as well, such as device drivers. Meanwhile, the default in Contiki has to always compile everything every time: even if a project would only use the IPv6 stack, the entire Rime stack would be compiled as well. With this patch, we get much better control as to what parts of the system that gets compiled.

The patch introduces a new makefile variable called `MODULES` that holds a list of modules with names like `core/net/ipv6`,  `core/net/rpl`, and `dev/cc2520`. These names correspond to the directory path that holds their code. Just like for `APPS`, this directory contains a makefile that lists all `.c` files that the module contains. 

This makes it easy to add new device drivers and new protocols: just add them as a module, and let individual projects and platforms include them.

The most visible part of this patch is that it (finally) moves the device drivers that previously was under `core/dev/` into separate directories such as `dev/cc2420` and `dev/sht11`. Also:

* The IP stack is split into three modules, `core/net/ip` (generic IP code), `core/net/ipv4`, and `core/net/ipv6`. 
* The Rime stack is put into its own module
* MAC layers are split into separate modules
* The core subdirectories are also modules, like `core/sys` and `core/lib`.

The patch also changes the way that platform makefiles handle custom makerules. The `MODULES` variable is  (re)defined in the platform makefile, which gets included by the top-level `Makefile.include` before the final list of `.c` files is produced. For custom make rules to work, they need access to the final list of `.c` files so they need to be included in a different part of `Makefile.include`. To make this work, this patch splits custom make rules into a separate makefile called Makefile.customrules-$(TARGET).

The patch is split into a fairly large amount of individual commits to make it easier to rebase the patch and to make it clearer what happened when later doing `git log` on the individual files.