added a layout layer; layout's still kind of a mess...

layout includes function keys, some symbols, and a few things from the
default layer
added convenience target 'dist-hex' to makefile
created a contrib folder
starting some changes on layer handling and key functions
changed default number of layers to 10
bugfix (mostly): changed the way layers are handled

before, if you pressed a key, then shifted layers, then released it, the
first layer's press() would be called, and the 2nd layer's release()
would be called, causing keys to stick, and probably other errors.  now,
the layer that the key was on when it was pressed is kept track of, and
the proper release() is called.

also, layers can be shifted per key now, instead of just for the whole
board at once

i also changed how keyboard-private includes are handled.  "private"
stuff is now in its own file, instead of being nested in an extra
`#ifdef`.

and i think that's it.  i'm pretty tired right now, so there may be
errors, but it seemed to work all right with cursory tests.
makefile now generates a .map
modified how dist is build; changed .gitignore hierarchy

there is now a toplevel makefile for making dist, so that we can keep
the project build systems separate (in src and contrib/UI*), and then
build dist from the root dir
(more makefile modifications)
(changed low level led macro names)
wrote kbfun for 2 shifts => capslock; other kbfun mods
added set layer function; more lib/keyfunctions* changes
added lib/key-functions private header
bug fixes, mostly; and other things

- addition to references.md

- keymap modification
  - now using 2 shifts => capslock
  - the previous capslock key -> tab
  - the previous tab key -> left bracket

- bug and omission fixes; notably:
  - _is_pressed() no longer changes the value of
    `keyboard_modifier_keys`, lol
  - kbfun_2_keys_capslock_press_release() now works.  (capslock doesn't
    register if left or right shift is pressed, so the shift state has
    to be stored, cleared, capslock pressed, and shift state restored)
  - main() no longer locally overwrites the value of `current_layer`
    before sending it to the kbfun.  (i didn't realize i was using the
    same variable name for two different things)

- improvements
  - kbfun_layer_inc() and ...dec() are now variable
test: using indices to an array of fn ptrs in layout matrices

so that _kb_layout_press... and ...release... are of type uint8_t
instead of kbfun_funptr_t (saving 1 byte per key per layer per matrix =
40% of the total layout size).

this brings the total firmware size with 10 layers to 6574 bytes instead
of 8302 bytes.  the teensy 2.0 has 32256 bytes of flash.

i'm going to revert to the old way.  partly because the space savings
don't seem consequential compared to what we have to work with.  mostly
because doing it with an array separates the function pointer to macro
(or const var) correlation in qwerty.c, and because i then have to
extern the _kb_layout_functions[6] array in layout.h (or qwerty.h).

also, using an enum instead of macros with manually assigned numbers
corresponding to the array indices would be more error prone, i think,
because (since it has to be visible outside qwerty.c) it would have to
be declared in a header.

hopefully all that makes sense.  i'm in a bit of a hurry.  but look at
the code: i think, even with a bit of formatting help, it'd still look
less clean
(reverting after test)

i did want to save the test code though
((removed something i'd forgotten))
mostly kbfun*() changes and additions

- changed KBFUN_FUNCTION_ARGS again

- changed kbfun's
  - condensed `kbfun_press()` and `kbfun_release()` to `kbfun_press_release()`
  - added `kbfun_toggle()`, which toggles keycodes on or off
  - added `kbfun_layer_inc_dec_press_release()` which is like
    ...press_release(), except it increments the layer first (and
    decrements it on keyrelease)
  - added `_kbfun_exec_key()` (which is a public kbfun*(), but not for
    assignment to keycodes) for convenience.  used by main(), and
    currently 1 of the kbfun*()s.  it doesn't save a lot of code, but i
    think it makes things slightly easier to read.  not quite as elegant
    a solution as i'd like, but it might have to do

- changed keymap accordingly

- changed main()
  - now using `_kbfun_exec_key()` (instead of essentially inlining the code)
  - now sending the USB report once every cycle.  i was sending once for
    every keypress (lol, by mistake: what i meant to do was only send it
    if any keys had been pressed).
separated kbfun_layer_inc_exec() and ...dec_exec()

also added another layer to _kb_layout_release[][][], mostly NULL, but
including at least one of each available kbfun*().  this way, all the
functions appear to be used, and none of them get optimised out by the
compiler
(small bug/typo fix)