Is there a better "Go" way to implement LC Add Two Numbers solution Problem Statement:

You are given two non-empty linked lists representing two non-negative integers. The digits are stored in reverse order, and each of their nodes contains a single digit. Add the two numbers and return the sum as a linked list.
You may assume the two numbers do not contain any leading zero, except the number 0 itself.

Implementation
func addTwoNumbers(l1 *ListNode, l2 *ListNode) *ListNode {
    return helper(l1, l2, 0)
}

func helper(left *ListNode, right *ListNode, carry int) *ListNode {

    if left == nil &amp;&amp; right == nil {
        if carry &gt; 0 {
            return &amp;ListNode{
                Val: carry,
            }
        }
        return nil
    }
    
    if left == nil {
        r := right.Val + carry
        return &amp;ListNode{
            Val:  r % 10,
            Next: helper(nil, right.Next, r / 10),
        }
    } else if right == nil {
        r := left.Val + carry
        return &amp;ListNode{
            Val:  r % 10,
            Next: helper(left.Next, nil, r / 10),
        }
    }

    r := left.Val + right.Val  + carry
    return &amp;ListNode{
        Val: r % 10,
        Next: helper(left.Next, right.Next, r / 10),
    }
}

```
Go does not have tail recursion: Wikipedia: Tail call. Use iteration rather than recursion.
Simplify your sprawling, hard-to-read code.

type ListNode struct {
    Val  int
    Next *ListNode
}

// Add Two Numbers
// https://leetcode.com/problems/add-two-numbers/
func addTwoNumbers(l1 *ListNode, l2 *ListNode) *ListNode {
    root := &amp;ListNode{} // at end, start = root.Next
    end := root

    c := 0
    for {
        if l1 == nil &amp;&amp; l2 == nil &amp;&amp; c == 0 {
            break
        }

        v := c
        if l1 != nil {
            v += l1.Val
            l1 = l1.Next
        }
        if l2 != nil {
            v += l2.Val
            l2 = l2.Next
        }
        c = v / 10
        v = v % 10

        end.Next = &amp;ListNode{
            Val:  v,
            Next: nil,
        }
        end = end.Next
    }

    return root.Next // start
}