Recursive relationships

Hi there 👋

I'm trying to work with recursive relationships.

```
TutorialD (master/main): rec := relation{tuple{src 0, tgt 1}, tuple{src 1, tgt 2}, tuple{src 2, tgt 3}}
TutorialD (master/main): :showexpr rec
┌────────────┬────────────┐
│src::Integer│tgt::Integer│
├────────────┼────────────┤
│0 │1 │
│1 │2 │
│2 │3 │
└────────────┴────────────┘
```

It seems to work ok for a depth 1 traversal:
```
TutorialD (master/main): :showexpr ((rec where src=0) join (rec rename {tgt as tgt2, src as tgt}))
┌────────────┬────────────┬─────────────┐
│src::Integer│tgt::Integer│tgt2::Integer│
├────────────┼────────────┼─────────────┤
│0 │1 │2 │
└────────────┴────────────┴─────────────┘
```

Also if I add an edge:
```
TutorialD (master/main): insert rec relation{tuple{src 1, tgt 4}}
TutorialD (master/main): :showexpr rec
┌────────────┬────────────┐
│src::Integer│tgt::Integer│
├────────────┼────────────┤
│1 │4 │
│2 │3 │
│1 │2 │
│0 │1 │
└────────────┴────────────┘
TutorialD (master/main): :showexpr ((rec where src=0) join (rec rename {tgt as tgt2, src as tgt}))
┌────────────┬────────────┬─────────────┐
│src::Integer│tgt::Integer│tgt2::Integer│
├────────────┼────────────┼─────────────┤
│0 │1 │2 │
│0 │1 │4 │
└────────────┴────────────┴─────────────┘
```

I can work out a way to do a depth 2 traversal:
```
TutorialD (master/main): :showexpr ((rec where src=0) join (rec rename {tgt as tgt2, src as tgt}) join (rec rename {tgt as tgt3, src as tgt2}))
┌────────────┬────────────┬─────────────┬─────────────┐
│src::Integer│tgt::Integer│tgt2::Integer│tgt3::Integer│
├────────────┼────────────┼─────────────┼─────────────┤
│0 │1 │2 │3 │
└────────────┴────────────┴─────────────┴─────────────┘
```

Can this be generalised to a depth `n` traversal? Also would it be possible to group the result by depth?

Thanks for your time!

Jun