This is a personal note, though any correction to my possible misunderstandings below are most welcome.
Nice comments mostly taken from Racket's source.
I'll need to keep this implementation in my mind for developing my theory for lazy evaluation.

[delay] and [lazy] are implemented as [promise], which is a [struct] containing a mutable filed (pointer).
[lazy] implements a composable promise: a single [force] iterates through the whole chain of composed [lazy] objects, tail-calling each step.

A promise can hold

(list < value > ...): forced promise
< promise >: a shared (redirected) promise that points at another one
- possible only with composable promises
< thunk>: usually a delayed computation
- can also hold a `running' thunk that will throw a reentrant error
- can also hold a raising-a-value thunk on exceptions and other `raise'd values, in order to memorize exception-raising behaviour.

Black holes as exceptions is non-r6rs. [1,2] discuss a faster implementation of composable promises by not keep banging the root promise value on each iteration.

(Generic) promises are forced in a standard fashion: update the promise with an exception-raising thunk, force the promise by calling the thunk held by the promise and update the promise with the value thus computed.

Carefully force composable promises, so that it is space-safe and tail-calling.

 let rec x1 = lazy x2 and x2 = lazy x3 and x3 = lazy 4 
we get
 x2 -> x1 -> 4
 let rec x1 = lazy x2 and x2 = delay (force x3) and x3 = delay 4 
we get
x1 -> x2 -> 4
x3 -> 4

This structure is partially visible in the error messages from the following programs.

(define a (letrec ([a (lazy b)] [b (lazy c)] [c (lazy b)]) a))
(force a)
force: reentrant promise 'a
So b is redirected to a.

(define b (letrec ([a (delay (force b))] [b (delay (force c))] [c (delay (force b))]) a))
(force b)
force: reentrant promise 'b
No sharing.

(define c (letrec ([a (lazy b)] [b (delay (force a))]) a))
(force c)
force: reentrant promise 'b
a is redirected to b.

(define d (letrec ([a (lazy (force b))] [b (delay (force a))]) a))
(force d)
force: reentrant promise 'a
No sharing.

(define e (letrec ([a (lazy b)] [b (delay (force c))] [c (lazy d)] [d (delay (force a))]) a))
(force e)
force: reentrant promise 'b
Nothing new.
[1] SRFI 45: Primitives for Expressing Iterative Lazy Algorithms, Post-finalization discussion.
[2] Richard Jones. Tail recursion without space leaks, Journal of Functional Programming, 2(1):73-79, January 1992