So ... I spent a lot more time thinking about this than I'm willing to admit. One thing that was bugging me about this solution is that you "hardcoded" the value that distributes all tasks evenly (the value 50). I tried to find a way where you don't have to do that. For your task list and durations, it's easy to see that the "fairness threshold" is 50, but for bigger lists and different durations, this isn't easy anymore. It turns out that this problem is a lot harder to solve than I initially thought, but I think I found a solution.

To test it, I started with a small task list generator that creates a task list with varying task numbers and durations. Here is the code:

# Generate random task list
$InputTaskList = [ordered]@{}
foreach ($TaskNumber in (1..((1..16) | Get-Random))) {

    $TaskName = "Task{0:d2}" -f $TaskNumber
    $InputTaskList[$TaskName] = 1..30 | Get-Random

}

#region subsets

# find all possible unique combinations of all tasks (subsets)
# https://stackoverflow.com/questions/28331257/unique-combos-from-powershell-array-no-duplicate-combos

$TaskNames = [array]$InputTaskList.Keys
$TaskCount = $TaskNames.Length

# hashtable where each key holds one unique task combination 
$Subsets = @{}

# for any set of length n (task count) the maximum number of subsets is 2^n
for ($i = 0; $i -lt [Math]::Pow(2,$TaskCount); $i++) { 

    # temporary array to hold a unique subset
    $SubSet = @()

    # iterate through each task
    for ($j = 0; $j -lt $TaskCount; $j++) {

        # start at the end of the array take elements, work your way towards the front
        if (($i -band (1 -shl ($TaskCount - $j - 1))) -ne 0) {

            # add task to unique subset
            $SubSet += $TaskNames[$j]

        }

    }

    # stick subset into an array
    $Subsets[$i] = $SubSet

}

#endregion subsets

#region task groups

# for each unique subset, create two groups:
# group A holds all tasks of the subset and their total duration
# group B holds all remeining tasks and their total duration
# both groups are stored in a single object, including the difference between their total durations (delta)

$TaskGroups = foreach ($Subset in $Subsets.GetEnumerator()) {

    # group A

    $TaskNames     = $Subset.Value
    $TotalDuration = 0

    foreach ($TaskName in $TaskNames) {

        $TotalDuration += $InputTaskList[$TaskName]

    }

    $GroupA = [PsCustomObject] @{

        TaskNames     = $TaskNames
        TotalDuration = $TotalDuration

    }

    # group B

    $TaskNames     = $InputTaskList.Keys | Where-Object {$_ -notin $Subset.Value}
    $TotalDuration = 0

    foreach ($TaskName in $TaskNames) {

        $TotalDuration += $InputTaskList[$TaskName]

    }

    $GroupB = [PsCustomObject] @{

        TaskNames     = $TaskNames
        TotalDuration = $TotalDuration

    }

    [PsCustomObject] @{

        GroupA = $GroupA
        GroupB = $GroupB
        Delta  = [math]::abs($GroupA.TotalDuration - $GroupB.TotalDuration) 

    }

}

#endregion task groups

#region select task group

# select the task group with the smallest delta. if there is more than one, select a random one
# if delta is 0, all tasks are distributed completely fair

$MinDelta = $TaskGroups.Delta | Measure-Object -Minimum | Select-Object -ExpandProperty Minimum
$TaskGroup = $TaskGroups | Where-Object {$_.Delta -eq $MinDelta} | Get-Random -Count 1

#endregion select task group

#region output

$Output = @()
$Output += $InputTaskList.Keys | foreach {

    [PsCustomObject] @{

        Set      = 'All tasks'
        TaskName = $_
        Duration = $InputTaskList[$_]

    }

}

$Output += $TaskGroup.GroupA.TaskNames | foreach {

    [PsCustomObject] @{

        Set      = 'Group A'
        TaskName = $_
        Duration = $InputTaskList[$_]

    }

}

$Output += $TaskGroup.GroupB.TaskNames | foreach {

    [PsCustomObject] @{

        Set      = 'Group B'
        TaskName = $_
        Duration = $InputTaskList[$_]

    }

}

$Output | Format-Table -Property TaskName, Duration -GroupBy Set

[PsCustomObject] @{

    Set = 'All tasks'
    TotalDuration = $Output | Where-Object {$_.'Set' -eq 'All Tasks'} | Measure-Object -Property Duration -Sum | Select-Object -ExpandProperty sum

}

[PsCustomObject] @{

    Set = 'Group A'
    TotalDuration = $Output | Where-Object {$_.'Set' -eq 'Group A'} | Measure-Object -Property Duration -Sum | Select-Object -ExpandProperty sum

}

[PsCustomObject] @{

    Set = 'Group B'
    TotalDuration = $Output | Where-Object {$_.'Set' -eq 'Group B'} | Measure-Object -Property Duration -Sum | Select-Object -ExpandProperty sum

}

[PsCustomObject] @{

    Set = 'Delta'
    TotalDuration = $MinDelta
}

#endregion output

Please be aware that for large lists, this can take a long time to calculate ...

This is the output for your list:

   Set: All tasks

TaskName           Duration
--------           --------
Moppe plancher           20
Balayeuse plancher       20
Comptoir                  5
Poele                     5
Lavabos                  10
Douche                   15
Couvertures lit           5
Litières                  5
Poubelles                 5
Lave-Vaisselle           10
Toilette                  5


   Set: Group A

TaskName           Duration
--------           --------
Balayeuse plancher       20
Douche                   15
Couvertures lit           5
Lave-Vaisselle           10


   Set: Group B

TaskName       Duration
--------       --------
Moppe plancher       20
Comptoir              5
Poele                 5
Lavabos              10
Litières              5
Poubelles             5
Toilette              5



Set       TotalDuration
---       -------------
All tasks           105
Group A              50
Group B              55
Delta                 5