Don't align unnecessarily

Just assert alignment.

runtime.c

···
 
 // To implement by the user:
 size_t heap_object_size(struct gc_obj* obj);
-size_t trace_heap_object(struct gc_obj* obj, struct gc_heap* heap,
-                         VisitFn visit);
+void trace_heap_object(struct gc_obj* obj, struct gc_heap* heap, VisitFn visit);
 void trace_roots(struct gc_heap* heap, VisitFn visit);
 
 struct space {
···
   uintptr_t scan = heap->base;
   while (scan < heap->hp) {
     struct gc_obj* obj = (struct gc_obj*)scan;
-    scan += align_size(trace_heap_object(obj, heap, assert_in_heap));
+    size_t size = heap_object_size(obj);
+    uword end = scan + size;
+    assert(is_size_aligned(end));
+    trace_heap_object(obj, heap, assert_in_heap);
+    scan = end;
   }
 }
 
···
   trace_roots(heap, visit_field);
   while (scan < heap->hp) {
     struct gc_obj* obj = (struct gc_obj*)scan;
-    scan += align_size(trace_heap_object(obj, heap, visit_field));
+    size_t size = heap_object_size(obj);
+    uword end = scan + size;
+    assert(is_size_aligned(end));
+    trace_heap_object(obj, heap, visit_field);
+    scan = end;
   }
   // TODO(max): If we have < 25% heap utilization, shrink the heap
 #ifndef NDEBUG
···
   return result;
 }
 
-size_t trace_heap_object(struct gc_obj* obj, struct gc_heap* heap,
-                         VisitFn visit) {
+void trace_heap_object(struct gc_obj* obj, struct gc_heap* heap,
+                       VisitFn visit) {
   switch (obj_tag(obj)) {
     case TAG_LIST:
       visit(&((struct list*)obj)->first, heap);
···
       fprintf(stderr, "unknown tag: %u\n", obj_tag(obj));
       abort();
   }
-  return heap_object_size(obj);
 }
 
 bool smallint_is_valid(word value) {
···
 
 struct object* mkclosure(struct gc_heap* heap, ClosureFn fn,
                          size_t num_fields) {
-  uword size = align_size(sizeof(struct closure) + num_fields * kPointerSize);
+  uword size = sizeof(struct closure) + num_fields * kPointerSize;
+  assert(is_size_aligned(size));
   struct object* result = allocate(heap, TAG_CLOSURE, size);
   as_closure(result)->fn = fn;
   as_closure(result)->size = num_fields;
···
 }
 
 struct object* mkrecord(struct gc_heap* heap, size_t num_fields) {
-  uword size = align_size(sizeof(struct record) +
-                          num_fields * sizeof(struct record_field));
+  uword size = sizeof(struct record) + num_fields * sizeof(struct record_field);
+  assert(is_size_aligned(size));
   struct object* result = allocate(heap, TAG_RECORD, size);
   as_record(result)->size = num_fields;
   // Assumes the items will be filled in immediately after calling mkrecord so