For a reason that I'm not familiar with, Invoke-Expression is converting your ArrayList to a HashTable. If you really need an ArrayList in script2.ps1, you can make $al a global variable (see below).

Updated script1.ps1

$al = New-Object System.Collections.ArrayList
$obj = @{"var1" = "apple"; "var2" = "banana"; "var3" = "carrot"; }
$al.Add($obj)

foreach ($i in $al) {
    $temp = $($i.var1)
    write-host "$temp"     
}

$Global:al = $al

invoke-expression -Command "$PSScriptRoot\script2.ps1"

Updated script2.ps1

param()

$Global:al.GetType().FullName

foreach ($i in $Global:al) {
    $temp = $($i.var1)
    write-host "$temp"     
}

The challenge is to add a copy of the $fooChild [pscustomobject] instance you're re-using every time you add to the list with .Add() (if you don't use a copy, you'll end up with all list elements pointing to the same object).

However, you cannot clone an existing [pscustomobject] (a.k.a [psobject]) instance with New-Object PSObject -Property.

One option (PSv3+) is to define the reusable $fooChild as an ordered hashtable instead, and then use a [pscustomobject] cast, which implicitly creates a new object every time:

$fooCollection = [PSCustomObject] @{ fooChildrenList = New-Object Collections.ArrayList } 

# Create the reusable $fooChild as an *ordered hashtable* (PSv3+)
$fooChild = [ordered] @{ childName = ''; childAge = -1 }

# Create 1st child and add to list with [pscustomobject] cast
$fooChild.childName = 'Betsy'; $fooChild.childAge = 6
$null = $fooCollection.fooChildrenList.Add([pscustomobject] $fooChild)

# Create and add another child.
$fooChild.childName = 'Rolf'; $fooChild.childAge = 10
$null = $fooCollection.fooChildrenList.Add([pscustomobject] $fooChild)

# Output the children
$fooCollection.fooChildrenList

^{Note the $null = ..., which suppresses the typically unwanted output from the .Add() method call.}

The above yields:

childName childAge
--------- --------
Betsy            6
Rolf            10

A slightly more obscure alternative is to stick with $fooChild as a [pscustomobject] instance and call .psobject.Copy() on it to create a clone.

ArcSet's helpful answer provides a more modular solution that creates new custom-object instances on demand via a helper function.

Finally, in PSv5+ you could define a helper class:

$fooCollection = [PSCustomObject] @{ fooChildrenList = New-Object Collections.ArrayList } 

# Define helper class
class FooChild {
  [string] $childName
  [int]    $childAge
}

# Create 1st child and add to list with [pscustomobject] cast
$null = $fooCollection.fooChildrenList.Add([FooChild] @{ childName = 'Betsy'; childAge = 6 })

# Create and add another child.
$null = $fooCollection.fooChildrenList.Add([FooChild] @{ childName = 'Rolf'; childAge = 10 })

# Output the children
$fooCollection.fooChildrenList

Note how instances of [FooChild] can be created by simply casting a hashtable that has entries matching the class property names.

If this is just about for-display formatting, i.e. what is shown in the implicitly table-formatted display output, you can call Format-Table explicitly and use a calculated column to apply custom formatting to the BranchName column:

# Sample result.
$result = [pscustomobject]@{
  RepositoryName = 'name'
  RepositoryId = 'id'
  BranchName = 'branch1', 'branch2', 'branch3'
  PolicyName = 'policy'
}

# Use explicit Format-Table formatting with custom formatting of the 
# 'BranchName' column.
$result | Format-Table RepositoryName, 
                       RepositoryId, 
                       @{ n='BranchName'; e={ $_.BranchName -join ', ' } },
                       PolicyName

The above yields a tabular display whose BranchName column doesn't have the enclosing { ... }, which PowerShell uses to indicate that the column value is an array (perhaps confusingly, because it looks like a script block):

RepositoryName RepositoryId BranchName                PolicyName
-------------- ------------ ----------                ----------
name           id           branch1, branch2, branch3 policy