I know the question was directed at Sam but I’d like to chip in with a few observations of my own.
As usual with CSS the answer is again “it depends…” 
For many years I was a strong advocate of clean mark up and would go to any length to avoid adding classes or ids to my html if I could target them from a parent and use descendant selectors.
Lets take a case in point in your code:
#header div:last-of-type span {
margin-left: 0.5em;
color: #fcab15;
}
The code above is now html dependent and will only work if the html is in exactly that structure. If your client adds a span (or widget/social icon) at the end of the line he not only has to address the code he is adding but the whole hierarchy of that structure in order to complete the task successfully. (It is also likely that your ids will outweigh any code that comes with the widget or third party plugin and break its display).
Now take the following css:
.info {
margin-left: 0.5em;
color: #fcab15;
}
<span class="info">Info</span>
The css has now been immediately decoupled from the html and the client can add a span or do whatever without needing to go back and adjust every counted span in that section. Immediately the specificity is simple and the code is effective and easily maintained. The only drawback is the extra class in the html which has negligible impact on performance on the html even if you add thousands of them (which I don’t advocate).
So again we get into a situation where we are trying to say “one size fits all” but that is seldom the case. If I was working on my own site that no one else was going to manage I would use classes and ids sparingly but when I work for clients (I have created literally many hundreds of templates for clients over the last twenty years) the best practice is to try and make it idiot proof and keep it simple.
For css performance ID selectors are parsed quicker but only when you target the element with the id. Once you say something like #id span{} then there is virtually no difference in performance because css works from right to left. This means that using ids really doesn’t give you any benefit so you may as well make it simple and stick with classes and avoid any specificity issues.
The other part of the puzzle is overuse of descendant selectors because descendant selectors are slow especially when you get more than 2 deep and once again ties your css to the structure of the mark up and we were supposed to be separating concerns.
Lastly, it doesn’t really matter how you do it if you are the only one using the code and you know what you are doing. A good coder is free to use all the techniques at their disposal because they understand all the complexities of what they are doing. If you are building templates for others to use then I would advocate the simpler the better approach which in turn lends itself to more modular css rules and shorter code even though you may use more classes. To be honest I fought against this for years but time and time again I came un-stuck because my code was too specific to the html and clients would change the design half way through or constantly add and change things as the project developed. Using classes and avoiding deep descendant selectors made the sites easier to manage and easier to change.
For your code above I would look to compose something like the following.
<!DOCTYPE HTML>
<html>
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Untitled Document</title>
<style>
.header {
padding:0.75em 1em;
background-color: #000;
text-align: center;
color:#fff;
}
.sign-in{
float: left;
color: #fff;
text-decoration: none;
}
.sign-in:hover {color: #fcab15;}
.help{float: right;}
.free {display: inline-block; }
.free b {margin-left: 0.5em;}
</style>
</head>
<body>
<div class="header">
<a class="sign-in" href="index.html"> Sign in/Register</a>
<span class="help">Need Help? : 02080207651</span>
<span class="free">FREE International shipping on<b>Selected Items</b></span>
</div>
</body>
</html>
However if it was for my own personal project then I would probably lose a couple of the classes and use similar methods to you but the above code is immediately more compact and more maintainable.
In the end it’s a matter of choice but I often find that simplest is the best even if it means adding an extra class. I am not averse to using the odd ID or an extra descendant selector but I am very careful in their use and restrain them to small controlled areas.
As usual opinions differ and that’s fine but I have certainly changed my mind on the code that I use now and will always look to simplify even if that means an extra class.
