Since you didn't provide links to these tutorials that confused you, I am going to assume that they weren't written by idiots and that the code in them is correct (where possible).
They're all correct (well, except transpose guy; I'll get to him). Your problem (likely stemming from the writers not being clear) is that you're not seeing the other differences in the examples.
A matrix converts vectors from space A to space B. The columns of this vector are the basis vectors of space A, expressed in the space of B. It is what space A looks like to objects in space B.
The TBN matrix is composed from 3 normals which are all in some space. That's your space A, the source space for the transform. The destination is of course tangent space.
Therefore, if you construct a matrix from these 3 normals, using them as the columns of the matrix, you will have created a matrix that goes from whatever space those normals were in to tangent space. What space those normals are in is entirely up to the code in question. I'm sure some example code transforms the normals to camera space before putting them in the matrix. I'm sure other example code transforms them to world space.
Again, it's all about what the code is doing; conceptually, it all does the same thing. This (note: it is likely that the transform of the normals is in the vertex shader, while the multiplication is in the fragment shader):
mat3 worldToTangent_tbn = mat3(
normalModelToWorld * tangent,
normalModelToWorld * bitangent,
normalModelToWorld * normal)
vec3 tangent_space_light_direction = worldToTangent_tbn * world_space_light_direction;
//do lighting in tangent space.
Is fundamentally no different from this:
mat3 cameraToTangent_tbn = mat3(
normalModelToCamera * tangent,
normalModelToCamera * bitangent,
normalModelToCamera * normal)
vec3 tangent_space_light_direction = cameraToTangent_tbn * camera_space_light_direction;
//do lighting in tangent space.
They both get the light direction into tangent space. You can even do things directly from model space (which is what I suggest):
mat3 modelToTangent_tbn = mat3(
tangent,
bitangent,
normal)
vec3 tangent_space_light_direction = modelToTangent_tbn * normalCameraToModel * camera_space_light_direction;
//do lighting in tangent space.
That requires transforming the camera-space light direction into model space, so you need a matrix to do that. Or you could do that transformation on the CPU and save time, so you'd be passing the model-space light position/direction.
So there isn't just one possible TBN matrix; there are many forms. It's all about what space you want to transform from and to.
And this is just my personal opinion, but if you see a tutorial that suggests you do lighting in world space, stop reading it. Read something written by someone who's not an idiot.
As for transpose guy, he is simply wrong. The transpose of a pure rotation matrix is its inverse, so what he's doing is take a matrix that transforms from normal space (the space the normals are in, which as shown above is dealer's choice) to tangent space and doing it backwards. The goal of that is to transform the normal fetched from the tangent space bump map into the space of the normals, so that you can do your lighting computations in a space other than tangent space.
His erronous assumption is that the TBN matrix is a rotation matrix; it isn't. TBN matrices will almost never be orthonormal; even if you compute the bitangent by cross-product, the normal and the tangent do not have to perpendicular, and they often will not be. Indeed, they should only be perpendicular if the surface is flat. The tangent and bitangent point along the flow of the surface in the S and T components of the UV. That's almost never in the plane of the normal.
