Key Points

• I would not use local variables to hold recordset values, because you'd need one for every field of every returned row... which is just wrong.
• As already pointed out, good variable names are readable variable names (which can be pronounced!).
• You're not showing it, but make sure you close that connection once you're done.

"Entities"

Here's an [perhaps less appealing] alternative to Dictionary. Since I learned about C# and started using Entity Framework, I like wrapping each record in an object - given a class called MyEntity (which does nothing more than exposing getters and setters for all properties):

Private Type ThisEntity
    SomeProperty As String
    AnotherProperty As String
End Type

Private this As ThisEntity
Option Explicit

Public Property Get SomeProperty() As String
    SomeProperty = this.SomeProperty
End Property

Public Property Let SomeProperty(value As String)
    this.SomeProperty = value
End Property

Public Property Get AnotherProperty() As String
    AnotherProperty = this.AnotherProperty
End Property

Public Property Let AnotherProperty(value As String)
    this.AnotherProperty = value
End Property

You define this object only once, and then you instantiate it as many times as you have records in your recordset. With a dictionary you get easier loading (each "entity" is a dictionary where you identify each field by their names to retrieve the corresponding value), but with this object you completely avoid referring to your properties using strings - the only hard-coded strings involved are the field names.

Reading the recordset

All you need to do is exactly as you said, loop through the recordset:

Dim entity As MyEntity
Dim entities As New Collection
While Not rs.EOF And Not rs.BOF 'BOF check if result has 0 rows

    Set entity = New MyEntity
    With entity
        .SomeProperty = rs.Fields("SomeField").Value 'or rs!SomeField
        .AnotherProperty = rs.Fields("AnotherField").Value 'or rs!AnotherField
    End With

    entities.Add entity ', entity.Id /PK property if you want to use a key here
    rs.MoveNext 'don't forget this, or your loop will be endless!
Wend

rs.Close
Set rs = Nothing
'at this point you have your entire recordset's content in the "entities" collection

About rs!FieldName notation (little "Gotcha!")

For what it's worth, I've recently fixed a bug in our codebase that was caused by the rs!FieldName notation in a specific circumstance: rs!FieldName was being added to a collection, and the recordset was left open. When I found that out, I added rs.Close and all of a sudden the collection, although non-empty, could no longer be read. This is because adding rs!FieldName to the collection (or, if you take the dictionary road) was actually adding a reference to the Field object, and the original programmer was left with the impression it worked fine because he could retrieve any entry in the collection and see the field's value - when he was actually retrieving a Field object and through the default property was fetching the value from the recordset: that stopped working when I added code to close the recordset after all records were read.

That bug was fixed by explicitly adding rs.Fields("FieldName").Value to the collection instead.