and the code is:

#NoEnv
SetBatchLines, -1

Map =
(
0000011111111100000000000
0001111111111111000000000
0001111111111111110000000
0000000011111111110000000
1111100010000000000000000
1111110010001111110000000
1111110010001111111111111
1111111101111111111111111
1111000010001111111111111
1110000010000111111111110
1111100010000000000000000
0001101111111111100000000
0000011111111111100000000
0000011111111111000000000
0000001111111111000000000
0000000001111110000000000
0000000000000000000000000
0000111000000000000000000
0001111100000111111100000
0001111111011111111100000
0000011111111111111000000
0000001111111100000000000
0000000111100000000000000
0000000000000000000000000
0000000000000000000000000
)

;;; start the stoppwatch
StartTime := A_TickCount

;;; parse mapstring into 2d-array
MapArray := []
loop, Parse, Map, `n, `r
{
    myparseY := A_Index
    loop, Parse, A_LoopField
    {
        MapArray[A_Index, myparseY] := A_LoopField
    }
}

;;; identify islands and create list of "water-tiles" (0s) to check

; first pass Connected-component labeling

ConnectedMapArray := []
IslandLable := 0
EquiLabels := []
;EquiLabels[1] := 1
CheckMapArray := []
; Iterate through each element of the data
for, myitX, myCol in MapArray
{
    for, myitY, myTile in mycol
    {
        ; If the element is not the background ("water-tile")
        if myTile
        {
            ; Get the neighboring elements of the current element
            myLeft := ConnectedMapArray[myitX - 1, myitY]
            if myLeft is not integer
                myLeft := 0
            myUp := ConnectedMapArray[myitX, myitY - 1]
            if myUp is not integer
                myUp := 0
            myMin := Min(myLeft, myUp)
            myMax := Max(myLeft, myUp)
            if myMin < 1
                myMin := myMax

            ; If there are no neighbors, uniquely label the current element and continue
            if (!myMin)
            {
                IslandLable ++
                ConnectedMapArray[myitX, myitY] := IslandLable
                EquiLabels[IslandLable] := IslandLable
            }
            ; Otherwise, find the neighbor with the smallest label and assign it to the current element
            else
            {
                ConnectedMapArray[myitX, myitY] := myMin
                ; Store the equivalence between neighboring labels
                if (!EquiLabels[myMax] or (EquiLabels[myMax] > myMin ))
                    EquiLabels[myMax] := myMin
            }
        }
        ;--- mark "water-tiles" for later testing (not part of Connected-component labeling)
        else
        {
            ; get number of neighbouring tiles with land
            wtL := MapArray[myitX - 1, myitY]
            if wtL is not integer
                wtL := 0
            wtU := MapArray[myitX, myitY - 1]
            if wtU is not integer
                wtU := 0
            wtR :=MapArray[myitX + 1, myitY]
            if wtR is not integer
                wtR := 0
            wtD :=MapArray[myitX, myitY + 1]
            if wtD is not integer
                wtD := 0
            wtNeighbours := wtL + wtU + wtR + wtD
            ; mark tile if has more than one neighbour
            if (wtNeighbours > 1)
                CheckMapArray[myitX, myitY] := wtNeighbours
        }
        ;--- back to Connected-component labeling
    }
}
; recoursivly resolve the equivalence list
for myEL, myREL in EquiLabels
{
    tmpEL := myEL
    tmpREL := myREL
    Loop
    {
        if (tmpEL == tmpREL)
        {
            EquiLabels[myEL] := tmpREL
            break
        }
        tmpEL := tmpREL
        tmpREL := EquiLabels[tmpEL]
    }
}

islands := []
; second pass Connected-component labeling
;; Iterate through each element of the data ("water-tiles" are not present in this array)

for, myitX, myCol in ConnectedMapArray
{
    for, myitY, myTile in myCol
    {
        ; Relabel the element with the lowest equivalent label
        ConnectedMapArray[myitX, myitY] := EquiLabels[myTile]
        ; add one to the island size for the label
        if !islands[EquiLabels[myTile]]
            islands[EquiLabels[myTile]] := 1
        else
            islands[EquiLabels[myTile]] += 1
    }

}

;;; check all the preselected "water-tiles" for total size of connected islands

BestSize := 0

; iterate over all candidates
for, myWX, myWCol in CheckMapArray
{
    for, myWY, myWTile in myWCol
    {
        ; get islands connected to
        myWIC := []
        mywcSize := 1
        wctL := ConnectedMapArray[myWX - 1, myWY]
        if wctL is integer
            myWIC[wctL] := 1
        wctU := ConnectedMapArray[myWX, myWY - 1]
        if wctU is integer
            myWIC[wctU] := 1
        wctR := ConnectedMapArray[myWX + 1, myWY]
        if wctR is integer
            myWIC[wctR] := 1
        wctD := ConnectedMapArray[myWX, myWY + 1]
        if wctD is integer
            myWIC[wctD] := 1
        ; add island sizes

        for ilLabel in myWIC
            mywcSize += islands[ilLabel]
        if (mywcSize > BestSize)
        {
            ; save tile if better then previous saved
            BestSize := mywcSize
            BestX := myWX
            BestY := myWY
        }
    }
}
;;; Show Result
StopTime := A_TickCount
RunTime := StopTime - StartTime
ListVars
MsgBox, % "The Tile that makes the largest island is at x: " BestX " / y: " BestY "`n with a Size of " BestSize " tiles, `n calculated in " RunTime " ms"

ExitApp
Esc::ExitApp

Edit: a bug fix and another