Is this matrix diagonalizable? Wolfram Alpha seems to contradict itself...

I agree with all the comments. Namely,

1. The matrix is clearly diagonalizable,
2. The rationalized version works correctly, and
3. Numerical linear algebra can be tricky and surprising.

In spite of points 2 and 3, I'd still call this a bug. Alpha is intended to guess the users intent. While clearly very hard, I don't think that interpreting numbers like $0.55$ as $55/100$ is too far out there. Even failing that, a small perturbation of the elements of the matrix don't change the fact that the matrix is diagonalizable.

Fortunately, there is an easy work around. Just enter:

diagonalize rationalize {{0.45,0.4},{0.55,0.6}}

This is a combination of numerical linear algebra being hard, bad error handling, and confusing output

1: Numerical linear algebra is hard

This problem is ill-conditioned as far as Mathematica is concerned. As has been mentioned in the comments, Mathematica (and it's wolfram-alpha cousin) automatically enters numerical approximation mode when you give it decimals. It assumes you have provided it with the data to the highest precision you can assert, and cannot tolerate imprecisions that exceed this implicitly provided precision threshold.

In your case, one of the entries has only a single digit of precision. Since the condition number is 23, you are expecting to lose $\log_{10}(23)>1$ decimal digits in precision, which exceeds the available precision.

This is hardly unique to your data. Trying to have Wolfram-Alpha diagonalize $$\begin{pmatrix}1.0&0.0\\0.0&1.0\end{pmatrix},$$ using the decimal points in particular, results in the same issue.

The algorithm therefore detects the system is ill-conditioned, and starts having problems.

2: Bad Error Handling

Rather than tell you that the problem is ill-conditioned and therefore prone to issues, it spits out that first message: "not diagonalizable." It should have said something to the effect of "problem is ill-conditioned; answers may not be accurate."

3: Confusing Output

Ah, but keep reading! Wolfram-alpha didn't give up when it saw it was ill-conditioned and started spouting nonsense about it being non-diagonalizable. It then did the next-best thing it felt it could do: provide a Jordan decomposition, which turns out to be precisely the diagonalization you want. Wolfram-alpha just doesn't trust that the decomposition is all that reliable.

4: Hidden Secret Bug/Interface shortcoming

Of course, there's a second problem. Intuitively you might think "okay, I'll just throw in some trailing zeros for more precision, problem solved!" Unfortunately, this doesn't work. Nor does trying to multiply the matrix by an arbitrary non-zero constant. From what I can gather, the algorithms Wolfram-Alpha (and essentially Mathematica) uses will effectively transform the entries back to the ill-conditioned 1 digit of precision situation, and then transform them back after it gets an answer (if any). Normally this is a worthwhile thing to do, as it guarantees that the numbers occupy the range that the algorithm and system can expect to handle the most efficiently. Here it just becomes a headache. I've yet to find a way that gets Wolfram-Alpha to interpret something like .4 as being accurate to, say, 32 decimal places.