TL;DR
Logic gate : A logic primitive provided by an analog designer as part of a library of logic primitive circuits that implement a select set of Boolean functions.
One way of looking at this is by breaking down the term and considering what the phrase "logic gate" suggests in the context of classical digital design where the term originated (classical meaning before computers did the work for us). The phrase is composed of two words, 'logic' and 'gate'. Let's analyze them separately.
I think it's clear that we associate a Boolean function with the term 'logic' here. A Boolean function may be expressed as F(x1, x2, x3,....,xn), where x1, x2,...etc are the inputs to the function. Conceivably, n can be an arbitrarily large number. But, actually writing down these functions for anything more than 4 inputs is tedious and unwieldy. But more, logic designers had techniques like Karnaugh maps to analyze and design logic functions that met their needs, and these techniques were only really useful up to 4 variables and maybe 5 if you really had to.
The upshot of this is that the phrase "Boolean function" has the association of only having a few inputs, even though theoretically, a Boolean function can have an arbitrary number of inputs.
Now, let's examine the term 'gate' in the same context. The idea of a gate is something that conditionally allows something to pass or not. When designing a large set of logic, it's helpful to have mental abstractions that subdivide the complexity into smaller units of understanding. The concept of a gate is one of these abstractions.
The idea is that we have a digital signal that we either want to pass or stop based on a condition. So, we wish to choose a Boolean function that implements the gate according to our specified conditions. An example of a basic gating function would be a 2 input AND, say with inputs A and B and output Q. In this case, we could mentally pick A to be the gating signal and B as the pass through signal. The gating could be expressed, "If A is high, then pass B to Q. If A is low, then block B from Q."
Some of these logic functions have the property that they will invert the passing signal though the gate. A design technique of using bubbles in the schematic to represent inversions was used to design and manipulate these inversions using De Morgan transformations of gates. In short, an AND could be converted to an OR with bubbles on it's inputs and outputs and other conversions like this. This was extremely useful for simplifying larger logic functions and making them robust against hazards. (The term 'hazard' has a special meaning for cases where a change in the logical inputs of a function don't change the logical output, but physical implementations of logic may cause a glitch in the output as the circuit stabilizes on the correct value.)
Thus, the term 'logic gate' may be used to describe a Boolean function that implements gating.
Now, to design a logical function with transistors (or whatever) is a lot of work. And perhaps ironically, it is a job for someone who has more analog design expertise than digital expertise. Thus, there is a natural division of labor between those who design logical primitives and those who use those logical primitives. So, there is a natural question for the overworked analog designer who is supposed to design these logic primitives: which Boolean functions should be implemented? They all can't be, so which subset should be chosen? What properties should this subset have? For start, the logic designer should be able to implement every logic function possible by composing the primitive functions. But more, they should be functions that are conceptually useful for the human designer to use.
With these types of design questions and practices in mind, it seems that the term 'logic gate' got assigned to describe the logic primitives that an analog designer provides to a logic designer as a library of circuits that implement Boolean functions.
Since these olden times, there has been more automation in designing logic gates and also in using them. Therefore, the number and kind of logic primitives in these libraries has gotten far away from the concept of logic gating. However, pragmatic considerations still encourage having a limited subset of logic primitives used by computers to build digital logic, though that set of logic functions is variable and larger than a human designer would know what to do with.
All this discussion necessarily precludes the logical structures that are better built using gates (see, I'm using the terminology). For example, an encoder is built using gates because it is the expertise of digital designers to build encoders, and it's not the expertise of analog designers to build such a thing, unless you propose building the encoder out of straight transistors. That would be overly-complex to say the least.
However, a MUX is small enough to be conceivably built using the available technology, and indeed, I can testify that MUX primitives are a part of some libraries I've used. Though, in my experience the computer tends to favor composing complex gates to build multiplexing functions instead of using MUX primitives. So, they seem to be there more for human consumption.
Now, you asked specifically about the XOR function. I have seen this implemented in logic libraries, and I consider this a gate. Now, it might be hard to think of this as implementing a literal gating function. However, it can be looked at as a conditional inverter. If one input is high, the other input gets inverted, and if low, then it's not inverted. That isn't the only way to think of the XOR function, but the logic doesn't care. Conceptualization is a human business.
Moreover, the XOR function is generally efficiently implemented using transistors, even more than if implemented using other gates. Therefore, it's a very useful logic primitive to have.
