Say what was hit, which way is out, and how far

The narrowphase has been producing a contact since it went in, and the interpreter
was throwing it away. `RCOLLISION(n, f)` reports it: what was hit (a sprite or a
`SOLID` rectangle), which one, the contact normal, the penetration depth, the
contact point, and which axis to reverse.

**The normal points out of the other thing and toward this one**, so a program
moves along it by the depth and is exactly clear. That sign is the one assertion
in the new test that could not be caught any other way -- both parties of a
sprite-against-sprite hit get their own record, each pointing the way *that*
sprite has to move, and sharing one would tell both to go the same direction,
which is how two things end up stuck inside each other.

**Field 7 is the one that deletes the most BASIC.** It is the minimum translation
axis, computed from the normal in C, and it is there because doing it in BASIC
means comparing two floats -- which is exactly where this dialect's left-operand
rule catches people. `BALLBRICKS`/`TESTCELL` in the artwork breakout spend six
lines computing an overlap rectangle and comparing its width to its height to get
this number.

The record is **sticky and deepest-wins**: replaced whenever that sprite is in a
contact and otherwise left alone, so `BUMP` stays the event and this stays the
detail of it. Making it clear itself when nothing touches would break the pairing,
because `BUMP` accumulates across steps and a once-a-frame poll would find the
detail already gone. Reading `BUMP` clears both, so they cannot disagree.

Deliberately narrower than `akgl_Contact`: no actor pointers, because BASIC has no
actor; no tile fields, because there is no tilemap; no z, because every test is
planar; and **no `dt` and no `sensor`**, which libakgl documents as filled in by
the resolver. This interpreter never resolves anything, so those two come back
zero and mean nothing, and an always-zero field in a reference table is a lie.

Documented with the two caveats that matter: fields 2, 3 and 4 are floats and want
a `%` variable, and the contact *point* is exact only for two boxes -- libakgl's
solver returns a point on the portal it converged to, while the normal and depth
are exact for every pair.

Chapter 8's collision section stops claiming only type 1 exists, which has been
false since the previous commit.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01EwxGB6TdoVvZ11KQQME9cL

tests/mockdevice.h

@@ -57,6 +57,8 @@ typedef struct
     /* Sprites */
     uint16_t collisions;	/* what the next collisions() call reports	*/
     uint16_t solidcollisions;	/* and what the next solids() call reports	*/
+    akbasic_Contact contact;	/* what the next contact() call describes	*/
+    bool hascontact;
     int patternbytes[AKBASIC_MAX_SPRITES];  /* bytes the last define() carried, per sprite */
 } akbasic_MockDevice;
 
@@ -463,6 +465,22 @@ static akerr_ErrorContext *mock_spr_solid(akbasic_SpriteBackend *self, int id, b
     SUCCEED_RETURN(errctx);
 }
 
+static akerr_ErrorContext *mock_spr_contact(akbasic_SpriteBackend *self, int n,
+					    akbasic_Contact *dest, bool *found)
+{
+    PREPARE_ERROR(errctx);
+    (void)self;
+
+    FAIL_ZERO_RETURN(errctx, (dest != NULL && found != NULL), AKERR_NULLPOINTER,
+		     "NULL argument in contact");
+    *found = MOCK.hascontact;
+    if ( *found ) {
+	*dest = MOCK.contact;
+	dest->other = n;
+    }
+    SUCCEED_RETURN(errctx);
+}
+
 /* ---------------------------------------------------------------- fixture -- */
 
 /** @brief Reset the recorder and populate all three vtables. */
@@ -523,6 +541,7 @@ static void mock_devices_init(void)
     MOCK_SPRITES.solids		= mock_spr_solids;
     MOCK_SPRITES.shape		= mock_spr_shape;
     MOCK_SPRITES.solid		= mock_spr_solid;
+    MOCK_SPRITES.contact	= mock_spr_contact;
 }
 
 /** @brief Set what the next collisions() call will report. Bit n-1 is sprite n. */
@@ -539,6 +558,19 @@ static void mock_set_solid_collisions(uint16_t mask)
     MOCK.solidcollisions = mask;
 }
 
+/** @brief Set the contact the next contact() call will report. */
+__attribute__((unused))
+static void mock_set_contact(int what, double nx, double ny, double depth, int axis)
+{
+    memset(&MOCK.contact, 0, sizeof(MOCK.contact));
+    MOCK.contact.what = what;
+    MOCK.contact.nx = nx;
+    MOCK.contact.ny = ny;
+    MOCK.contact.depth = depth;
+    MOCK.contact.axis = axis;
+    MOCK.hascontact = (what != 0);
+}
+
 /** @brief Prime the input backend with keystrokes GET will drain in order. */
 __attribute__((unused))
 static void mock_push_keys(const char *keys)