Massive Cleanup

Coroutines

If you don't use coroutine.yield, there's no real point in using coroutine. Use spawn( instead of coroutine.resume(coroutine.create(.

Normally when you want use multiple threads, you don't need to, and probably shouldn't. In this case, you'll see, they were a bad idea. Coroutines add complexity (and bugs, in your case), and slow down your code. Don't use them if you don't need them. Use functions instead of background loops.

Use For Loops & Don't Repeat Yourself

Don't keep using game.Players:GetChildren()[i]. I would claim this is not even correct, let alone reasonable. Use a generic for loop to go over lists and you'll save a massive amount of typing and headaches. While you're at it, use :GetPlayers() instead of :GetChildren().

It's a bad idea to keep updating the lists in a loop. It'll easily be out-of-date and is a mess of unnecessary complexity. Instead, write a function that gives you everyone on a team:

function onTeam(color)
    local team = {}
    for _, player in pairs(game.Players:GetPlayers()) do
        if player.TeamColor == color then
            table.insert(team, player)
        end
    end
    return team
end

table.remove

Your use of table.remove is completely wrong. The first thing you have to give is the list, the second thing is the index (i).

Your way of going through the list and removing is incorrect. You should only increment i if you don't delete. Instead, you can go backwards, but use a for loop, which is so much cleaner:

        for i = #defending, 1, -1 do
            if (defending[i].Character.Torso.Position - script.Parent.Position).magnitude > 10 then
                table.remove(defending, i)
            end
        end

No spawning threads

This didn't need a coroutine or spawn at all. There was no reason for it to have a wait in it.

The third spawn is also redundant. Again, you shouldn't have a loop updating this table in the background. You should compute it where you need it.

No nested loops

The if shouldn't use while at all. Just check again after the next wait, but keep track of who has any points at all.

Here you have a script half the length, that does the same thing, but fixes a dozen bugs:

function onTeam(color)
    local team = {}
    for _, player in pairs(game.Players:GetPlayers()) do
        if player.TeamColor == color then
            table.insert(team, player)
        end
    end
    return team
end

local defendPoints = 0
local raidPoints = 0

while wait() do
    local raiding = onTeam(BrickColor.new("Bright red"))
    local defending = onTeam(BrickColor.new("Teal"))
    -- Filter down to those players capping:
    for i = #defending, 1, -1 do
        if (defending[i].Character.Torso.Position - script.Parent.Position).magnitude > 10 then
            table.remove(defending, i)
        end
    end
    for i = #raiding, 1, -1 do
        if (raiding[i].Character.Torso.Position - script.Parent.Position).magnitude > 10 then
            table.remove(raiding, i)
        end
    end
    -- Keep score:
    if #defending > 0 and #raiding == 0 then
        raidPoints = 0
        defendPoints = defendPoints + 1
    elseif #raiding > 0 and #defending == 0 then
        defendPoints = 0
        raidPoints = raidPoints + 1
    else
        defendPoints = 0
        raidPoints = 0
    end
    -- Update score display:
    script.Parent["Capture GUI"].DefendersCapture.Size = UDim2.new(0.1 * defendPoints, 0, 1, 0)
    script.Parent["Capture GUI"].RaidersCapture.Size = UDim2.new(0.1 * raidPoints, 0, 1, 0)
end

Error state checking

What's left to do is error handling. You are assuming that every person has a Character and that that Character has a Torso. That's not the case; you have to check for that. The easiest way is to check when adding in onTeam:

function onTeam(color)
    local team = {}
    for _, player in pairs(game.Players:GetPlayers()) do
        if player.TeamColor == color then
            if player.Character and player.Character:FindFirstChild("Torso") then
            table.insert(team, player)
        end
    end
    return team
end