Keep i64 off the number paths: lanes fold numbers, cells read as bytes

Counting user-mode instructions per query (bank, 100,000 accounts)
against ee21aec found what i64 had added to the number paths, and an
instruction sampler found where:

- fold_in took a union and asked whether the fold was of i64s for every
  item, in the group and leaf-at-a-time passes too, where a fold of
  i64s never runs (it is never planned). Those passes now call
  fold_number, which takes a double; fold_in keeps the i64 branch for
  folds run item by item. per_branch: 27.83M instructions an ask back
  to 27.05M (26.72M before i64).
- cell_at's third kind made it too big to inline into pure_list_get,
  so every item read became a call. A number's, bool's or integer's
  cell is 8 bytes read as they are (memcpy, so no aliasing rule is
  bent), one branch as before, and it inlines again. A table of 10,000
  rows: 8.78M instructions an ask to 8.70M (8.58M before i64).

Behaviour is unchanged; every check passes.

1 files changed, 9 insertions, 4 deletions

diff --git a/core/module-list.c b/core/module-list.c
index 51148eb..ac622cc 100644
--- a/core/module-list.c
+++ b/core/module-list.c
@@ -130,11 +130,16 @@ static double *numbers(const Layout *l, const Node *leaf, unsigned f) { return (
 static int64_t *integers(const Layout *l, const Node *leaf, unsigned f) { return (int64_t *)((char *)leaf + l->column[f]); }
 static PureSpan *texts(const Layout *l, const Node *leaf, unsigned f) { return (PureSpan *)((char *)leaf + l->column[f]); }
 
+/* A number's, bool's or integer's cell is its 8 bytes, read as they are
+ * (whichever it holds; the reader's kind says which). */
 static PureCell cell_at(const Layout *l, const Node *leaf, unsigned i, unsigned f) {
-    if (l->kinds[f] == PURE_CELL_INTEGER) return (PureCell){.i64 = integers(l, leaf, f)[i]};
-    if (!pure_cell_text(l->kinds[f])) return (PureCell){.num = numbers(l, leaf, f)[i]};
-    PureSpan text = texts(l, leaf, f)[i];
-    return (PureCell){.text = (unsigned char *)text.data, .size = text.size};
+    PureCell cell = {0};
+    if (!pure_cell_text(l->kinds[f])) memcpy(&cell.i64, (const char *)leaf + l->column[f] + 8 * (size_t)i, 8);
+    else {
+        PureSpan text = texts(l, leaf, f)[i];
+        cell.text = (unsigned char *)text.data, cell.size = text.size;
+    }
+    return cell;
 }
 
 static void put_cells(const Layout *l, Node *leaf, unsigned i, const PureCell *cells) {