Added `val`

Returns `x()` if `x` is a function; otherwise returns `x`.
Improved `variadic` tests and change behavior of `rest`

Previously, `rest` was always defined and passed, even if the
original call didn't supply enough arguments to reach `rest`.
This poses some problems when you expect the length of
`arguments` to match that of the original call to the variadic
function, so now `rest` is only supplied if there are actual
arguments to fill it up with. This means it'll be undefined
otherwise, and `arguments` will be identical to the original
call.

Additionally, I changed `variadic` so that it'll correctly
report `length` for the wrapped function, provided the wrapped
function `length` is 26 or below. I'd be hard pressed to
remember ever seeing a function with more than even 10
parameters, but still. This isn't an ideal solution of course,
but probably hits home 99.99% of the time which is enough.
Added `and` for logical testing

Will return the last value if all values are logically true;
or the first logically false value.
Added `get` for getting the value of a property

Very useful function for getting a property value out of an
object. If the object is undefined, will return `notFound`
which defaults to `undefined`. If the property doesn't exist
on the target object, will return `notFound` as well.
Fix a bug in `get` and improve tests

Would return `notFound` even if `map` had `key`, but where the
value was logically false.
Added `defprop` for adding properties to an object

This is a wrapper around `Object.defineProperties` which makes
it easier to add immutable and non-enumerable properties to
objects. Just like `Object.defineProperties`, this function
will mutate the object in place.

It *is* possible to make the properties both mutable and
enumerable (but not removable) – however this is by design
made to be uncomfortable.

Accessor functions or values that are functions will have
their scope bound to a private scope, which is an extension of
the target object. This allows functions to share data
internally, without fear of exposing anything to the outside
world. A caveat here is that subsequent calls to `defprop`
will create a *different* private scope, with the assumption
being that such calls imply that the properties are unrelated.
I may want to rethink this at some point.