You are correct, not all parts of Access are on the same page regarding the use of bang vs dot. In the early days, there was a much more rigid separation. That has blurred over the years but not all the programmers on the team got the memo so you will see differences within Access. Especially in SQL vs VBA. SQL is more likely to adhere to the original rules and VBA is more likely to be sloppy and allow variations some places but not others.
My understanding is that dot is used when referencing "Access" methods and properties and bang is used when referencing user defined methods and properties. This may be just a different way of saying what Maj quoted. One thing that has changed over the years is that fields from a bound recordsource are now considered part of the form/report's object model and are referenced using dot. In earlier versions of Access, if you had a field that was not bound to a control, you had to refer to it as me!someunboundfield, you could NOT refer to it as Me.someunboundfield. This leads us to why many developers use different names for controls than the fields they are bound to. If you have fieldA bound to a control named txtFieldA, you will see the difference in intellisense. Me.fieldA will show only the methods and properties of a field in the bound RecordSource whereas Me.txtFieldA will show the methods and properties of a control. This distinction allows you more precision when coding but it can lead to strangeness. For example if you code
Me.FieldA = "x"
the value will NOT show up in the control but it will modify the RecordSource
However:
Me.txtFieldA = "x"
will show up on the form, and when the record is saved, will be applied to the RecordSource.
In the early days:
Me!somefield. would NOT pop up intellisense
But
Me.somefield. would pop up intellisense
Today, both give you intellisense.
However, I believe the difference remains that dot is early binding and bang is late binding. The result of that is you might not see certain types of errors as you are coding. They will only show up at runtime. This is dangerous in my opinion so I always use dot as long as Access allows it. Unless your testing is sufficiently detailed so that you are certain that every path of every if is actually tested, using bangs may let errors slip through that are not discovered until some user runs into the other path.
The biggest difference in the two pieces of code in the initial question is the lack of using "Me." Using Me. when referencing form/control objects clarifies for the interpreter exactly which library holds the definition for that object. Without the "Me.", Access has to search multiple libraries to find where something is defined. it starts with the current procedure, works out to the current module, and then to other modules in the project. Then it goes to the Access library and if necessary to any other loaded modules. "Me." localizes this search to the form/report object. The time saving is minuscule but it all adds up.
Also, without the "Me.", you may not see intellisense at all.