[kernel] Pass objects not handles to syscall impls

This commit contains a couple large, interdependent changes:

- In preparation for capability checking, the _syscall_verify_*
  functions now load most handles passed in, and verify that they exist
  and are of the correct type. Lists and out-handles are not converted
  to objects.
- Also in preparation for capability checking, the internal
  representation of handles has changed. j6_handle_t is now 32 bits, and
  a new j6_cap_t (also 32 bits) is added. Handles of a process are now a
  util::map<j6_handle_t, handle> where handle is a new struct containing
  the id, capabilities, and object pointer.
- The kernel object definition DSL gained a few changes to support auto
  generating the handle -> object conversion in the _syscall_verify_*
  functions, mostly knowing the object type, and an optional "cname"
  attribute on objects where their names differ from C++ code.
  (Specifically vma/vm_area)
- Kernel object code and other code under kernel/objects is now in a new
  obj:: namespace, because fuck you <cstdlib> for putting "system" in
  the global namespace. Why even have that header then?
- Kernel object types constructed with the construct_handle helper now
  have a creation_caps static member to declare what capabilities a
  newly created object's handle should have.

definitions/objects/process.def

@@ -17,18 +17,10 @@ object process : kobject {
         param result int32    # The result to retrun to the parent process
     }
 
-    # Start the given process running. Note that the entrypoint
-    # address must be specified in the address space of the new
-    # process.
-    method start {
-        param entrypoint address            # The address of the main thread entrypoint
-        param handles object kobject [list] # A list of parent handles to send to the child process
-    }
-
     # Give the given process a handle that points to the same
     # object as the specified handle.
     method give_handle {
-        param sender object kobject                   # A handle in the caller process to send
-        param receiver object kobject [out optional]  # The handle as the recipient will see it
+        param target object kobject [handle]           # A handle in the caller process to send
+        param received object kobject [out optional]  # The handle as the recipient will see it
     }
 }