Messy results from simple cellular automata algorithm?

You require more effective smoothing methods. Google "cave generation" and you will find many. Also if you haven't already begun, some research on cellular automata will be beneficial.

This issue boils down to the way in which you treat each cell in your SmoothMap algorithm. At the moment all you do is count neighbours around the current cell, provided the current cell is itself already land, and act accordingly. This is a naive generation algorithm, and not the most intelligent way of adjusting the map because all you are doing is evaluating count and not structure.

Counting neighbours (Quantitative analysis)

You can get a bit further with neighbour-counting alone, than you are at present: Consider even cells that are currently water (unlike at the moment where you only consider land cells for neighbour-comparison). If it has a certain number of neighbours that are land, then fill this central cell with land as well. This in itself gives much more smoothing: it fills up tiny ponds with land.

If you can make what you want with just neighbour-counting, I suggest you do so, as it is a lot simpler than what follows below, BUT structural analysis (below) can provide much more control.

Expansion / dilation and contraction / constriction

You can see this in my other answer which I posted in the comments. It is perhaps not the most efficient way, but it is one alternative to smoothing and creating more rounded forms. It works, and is relatively simple. But there is a considerable loss of fine details, maybe more than you want.

Structural evaluation of neighbours (Qualitative analysis)

As I said in my previous answer to you, if you want to smooth and keep joins between islands etc. more effectively, you need to re-examine how you work with neighbours.

What you need now is a function that can go around in a circle (say clockwise from north) and examine each group of adjacently-populated neighbours. For example:

* * *
0 X *
* * 0

Here you can see that there is a group of 4 adjacent neighbours toward the northeast side, and 2 toward the southwest. Your algorithm might produce something like

0 * *
0 X 0
0 0 0

You can see that what we've done here is to erode by taking the "ends" off each segment - we took both ends (1 & 1) off the strip of length 2 at the southwest, leaving just water. We took both ends off the strip of length 4 at the northeast (1 & 1) leaving just 2.

Another way might be to say anything 2 or bigger always survives, so

0 * 0
0 X *
* 0 *

would become just

0 0 0
0 X *
0 0 *

Also, you'll notice I've been putting an X at the current position (to say we don't care what's there) but what if that becomes important to the adjacency in the previous example? Now this

0 * 0
0 * *
* 0 *

actually becomes

0 * 0
0 * *
0 0 *

instead, preserving a sort of land-bridge, as compared with the previous example which does not.

To allow you to find groups of adjacent neighbours, in order, use something like this:

Vector2 offsets[] = new Vector2[] 
{
    //CLOCKWISE:
    new Vector2( 0,-1), //north
    new Vector2(+1,-1), //northeast
    new Vector2(+1, 0), //east
    new Vector2(+1,+1), //southeast
    new Vector2( 0,+1), //south
    new Vector2(-1,+1), //southwest
    new Vector2(-1,-1), //west
    new Vector2(-1,-1)  //northwest

};

...

//walk clockwise around neighbours and find (start of) adjacent groups
for (int d = 0; d < 8; d++)
{
    Vector2 offset = offsets[d];
    Tile neighbour = tiles[centre.x + offset.x, centre.y + offset.y];
    //etc.
}

I think you will perceive that there are many ways to work on this. Ideally, take your time, play, experiment and familiarise yourself with different ways of recognising different neighbour segments and how to evaluate them structurally and then act on those structures.

Box filters: A reminder

Remember that box filters don't have to be 3x3. They can be 2x2, 5x5 or whatever you want (nxn). Be aware however, that the larger n is, the higher the cost of the algorithm across the grid. That means it will be slower to run. But you can potentially get more control with a higher n.

Remember to do filter-passes interactively as in the previous code I gave you, e.g. hit spacebar to see how it looks at each step, rather than just running the filter 8x and hoping for the best. Then you can eventually settle on your final numPasses figure to hardcode in.

NOTE: I haven't gone to the extent of writing code for you as I did last time, because now you need to explore and really understand the cellular automata you are working with, and experiment yourself with the code to achieve those goals, in order to fine tune the generation algorithm to get the exact look and feel that you want. I'm happy to provide pointers. Besides that, cellular automata are a powerful tool and are worth gaining a deeper insight into for any game dev.